Looking for the best free alternative to Semrush? GEOmind is a lightweight rank tracking API that gives you keyword position data, competitor displacement, citation velocity, and rank alerts — without a $140/month subscription. One HTTP call returns the SERP data you need. Free trial included. $0.001 per query after that. No monthly fee, no seat licences.
Built for SEO agencies that need to embed rank data in client dashboards, in-house SEO teams running automated audits, and e-commerce sites that need real-time position monitoring at scale — all without the overhead of a full platform subscription.
Semrush, Ahrefs, Serpwatch, and Accuranker are excellent platforms — but they bundle dozens of features into a monthly SaaS subscription. If your use case is: track X keywords for Y domains and fire an alert when anything changes, you are paying for a lot you don't use. GEOmind is the targeted alternative:
Sign up, copy your key from the dashboard, and send a GET request. No polling needed — the competitor displacement endpoint responds synchronously.
# Track who ranks for your target keyword
curl "https://api.pixelapi.dev/v1/geomind/competitor/displacement?keyword=seo+rank+tracker" \
-H "Authorization: Bearer YOUR_API_KEY"
# Response:
# {
# "keyword": "seo rank tracker",
# "scanned_at": "2026-05-26T10:00:00Z",
# "competitors": [
# {"domain": "semrush.com", "position": 1, "change": 0, "estimated_traffic": 42500},
# {"domain": "ahrefs.com", "position": 2, "change": 1, "estimated_traffic": 38200}
# ],
# "displacement_alerts": 2
# }
# Get active rank alerts
curl "https://api.pixelapi.dev/v1/geomind/alerts" \
-H "Authorization: Bearer YOUR_API_KEY"
import requests
API_KEY = "YOUR_API_KEY"
BASE = "https://api.pixelapi.dev/v1/geomind"
headers = {"Authorization": f"Bearer {API_KEY}"}
# Track keyword positions
resp = requests.get(f"{BASE}/competitor/displacement",
params={"keyword": "seo rank tracker"},
headers=headers)
data = resp.json()
for c in data["competitors"]:
arrow = "▲" if c["change"] > 0 else ("▼" if c["change"] < 0 else "—")
print(f"#{c['position']} {c['domain']} {arrow} ({c['estimated_traffic']:,} est. visits)")
# Get rank alerts
alerts = requests.get(f"{BASE}/alerts", headers=headers).json()
for a in alerts["alerts"]:
print(f"[{a['severity'].upper()}] {a['type']}: {a['message']}")
const BASE = "https://api.pixelapi.dev/v1/geomind";
const headers = { Authorization: `Bearer ${process.env.PIXELAPI_KEY}` };
// Track keyword positions
const res = await fetch(
`${BASE}/competitor/displacement?keyword=seo+rank+tracker`,
{ headers }
);
const { competitors, displacement_alerts } = await res.json();
competitors.forEach(c =>
console.log(`#${c.position} ${c.domain} (Δ${c.change > 0 ? "+" : ""}${c.change})`)
);
// Get rank alerts
const { alerts } = await (await fetch(`${BASE}/alerts`, { headers })).json();
alerts.forEach(a => console.log(`[${a.severity}] ${a.type}: ${a.message}`));
<?php
$key = getenv("PIXELAPI_KEY");
$base = "https://api.pixelapi.dev/v1/geomind";
$opts = ["http" => ["header" => "Authorization: Bearer $key"]];
$ctx = stream_context_create($opts);
// Track keyword positions
$url = "$base/competitor/displacement?" . http_build_query(["keyword" => "seo rank tracker"]);
$data = json_decode(file_get_contents($url, false, $ctx), true);
foreach ($data["competitors"] as $c) {
echo "#{$c['position']} {$c['domain']} — {$c['estimated_traffic']} est. visits\n";
}
// Get rank alerts
$alerts = json_decode(file_get_contents("$base/alerts", false, $ctx), true);
foreach ($alerts["alerts"] as $a) {
echo "[{$a['severity']}] {$a['type']}: {$a['message']}\n";
}
require "net/http"
require "json"
require "uri"
KEY = ENV["PIXELAPI_KEY"]
BASE = "https://api.pixelapi.dev/v1/geomind"
def geomind_get(path, params = {})
uri = URI("#{BASE}#{path}")
uri.query = URI.encode_www_form(params) unless params.empty?
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{KEY}"
JSON.parse(Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }.body)
end
# Track keyword positions
data = geomind_get("/competitor/displacement", keyword: "seo rank tracker")
data["competitors"].each { |c| puts "##{c['position']} #{c['domain']} (est. #{c['estimated_traffic']} visits)" }
# Get rank alerts
geomind_get("/alerts")["alerts"].each { |a| puts "[#{a['severity']}] #{a['type']}: #{a['message']}" }
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
)
func geomindGet(path string, params url.Values) map[string]any {
u, _ := url.Parse("https://api.pixelapi.dev/v1/geomind" + path)
u.RawQuery = params.Encode()
req, _ := http.NewRequest("GET", u.String(), nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("PIXELAPI_KEY"))
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
var out map[string]any
json.Unmarshal(body, &out)
return out
}
func main() {
// Track keyword positions
data := geomindGet("/competitor/displacement", url.Values{"keyword": {"seo rank tracker"}})
for _, c := range data["competitors"].([]any) {
comp := c.(map[string]any)
fmt.Printf("#%.0f %s (est. %.0f visits)\n", comp["position"], comp["domain"], comp["estimated_traffic"])
}
// Get rank alerts
alerts := geomindGet("/alerts", url.Values{})
for _, a := range alerts["alerts"].([]any) {
al := a.(map[string]any)
fmt.Printf("[%s] %s: %s\n", al["severity"], al["type"], al["message"])
}
}
Platform tools bundle rank tracking inside a large monthly subscription. GEOmind is a pay-per-query API — you pay for the data you actually pull.
| Tool | Free tier | Entry price | API access | Rank alerts | Citation velocity |
|---|---|---|---|---|---|
| PixelAPI GEOmind | 5,000 queries / 24h trial | $0.001 / query | ✓ Native REST | ✓ | ✓ |
| Semrush | Limited free searches | see semrush.com/prices | Add-on (paid tier) | ✓ (in platform) | — |
| Ahrefs | Ahrefs Webmaster Tools (limited) | see ahrefs.com/pricing | Add-on (paid tier) | ✓ (in platform) | — |
| Serpwatch | Limited trial | see serpwatch.io/pricing | Limited | ✓ (in platform) | — |
| Accuranker | 14-day trial | see accuranker.com/pricing | Via add-on | ✓ (in platform) | — |
Pricing verified from each rival's public pricing page May 2026. PixelAPI per-query price is set at exactly half the cheapest API-accessible rival per-call rate per our pricing principle. Platform-only tools without a public per-call API price are listed with a link to their pricing page.
Every endpoint returns structured JSON — no scraping, no parsing HTML. Here is what each call gives you:
For a given keyword: ranked domains, current SERP position, position change since last scan, and estimated organic traffic per domain. A displacement_alerts count flags keywords with significant recent movement.
GET /v1/geomind/competitor/displacement?keyword=...
Five alert types: rank_drop, rank_rise, competitor_new (new domain in top 5), sentiment_spike, and citation_surge. Each includes severity (high / medium / low) and a plain-text message ready to push to Slack or email.
GET /v1/geomind/alerts
Total citations for a keyword plus 24-hour, 7-day, and 30-day velocity counts. A 7-day trend array and acceleration figure let you detect early momentum before it shows in rankings. Top citing sources listed with first-seen dates.
GET /v1/geomind/citation/velocity?keyword=...
Overall sentiment score (0–1), bullish / bearish / neutral label, and per-channel breakdowns across news articles, social mentions, and blog posts. Includes a 7-day sentiment trend and top-impact headlines with their sources.
GET /v1/geomind/sentiment?keyword=...
Store snapshots with POST /v1/geomind/scan/save — pass a URL, keyword, and score and get back a scan ID and letter grade (A+, A, B+, B, C …). Retrieve your full log with GET /v1/geomind/scan/history to build rank-over-time charts.
GET /v1/geomind/scan/history · POST /v1/geomind/scan/save
Capability discovery for automated pipelines: GET /v1/geomind/agent/protocol returns the list of active capabilities, endpoint map, and heartbeat timestamp. POST /v1/geomind/agent/command lets orchestration systems issue structured commands and receive a result payload.
GET /v1/geomind/agent/protocol · POST /v1/geomind/agent/command
GEOmind is used as the data layer in these recurring SEO pipelines:
Cron job queries competitor displacement for your core keywords. Formats a markdown table. Sends to Slack. No spreadsheet, no manual pull.
Agency teams embed GEOmind data directly into client-facing dashboards. Each client gets real-time rank data without a per-seat Semrush licence.
Poll /alerts daily. When citation_surge fires on a target keyword, trigger a content sprint before competitors rank for the emerging topic.
Track top-10 competitors per product category. Alert when a new domain enters the top 5 for a high-revenue keyword and auto-generate a gap analysis.
Combine sentiment score with citation velocity to prioritise topics that are trending positive and accelerating — before editorial teams have to guess.
Loop through thousands of landing pages, save each scan score, retrieve the history, and surface underperforming pages automatically for your content team.
More workflow ideas: all use-case guides →
GEOmind is a standard REST API — it connects to any tool that can make an HTTP request:
Use the Webhooks by Zapier action to call GEOmind on a schedule. Route rank alerts to Slack, Google Sheets, or email in minutes.
The HTTP module in Make.com calls GEOmind endpoints directly. Build multi-step scenarios that react to rank drops and queue content tasks.
n8n's HTTP Request node plus a Cron trigger gives you a self-hosted rank monitoring workflow at near-zero cost per run.
Apps Script fetches GEOmind data and writes rows — positions, changes, estimated traffic — into a shared sheet your whole team can see.
Forward /alerts output to a Slack incoming webhook. Get high-severity rank drops in your SEO channel the moment they happen.
React, Vue, Svelte, Grafana — GEOmind returns JSON. Render rank trend charts, competitor tables, and citation velocity graphs in any frontend.
See the full integrations index: all integrations →
Semrush is a comprehensive platform. GEOmind is the rank data layer you embed when you already have a dashboard and only need the raw signal — at a fraction of the monthly cost.
Ahrefs excels at backlink analysis. GEOmind focuses on real-time rank position and citation velocity — the signals that change fastest and matter most for reactive SEO teams.
Serpwatch is a standalone rank tracker UI. GEOmind is the API underneath — build the UI you actually want, or skip the UI entirely and route data straight to Slack.
Accuranker charges per tracked keyword, per month. GEOmind charges per query. If your keyword set changes week to week — as it does for most agencies — per-query wins.
Default 60 requests/minute on the free tier, 600 requests/minute on paid tiers. Exceeding the limit returns HTTP 429 with a Retry-After header. Recommended: exponential backoff starting at 2 seconds, doubling on each retry up to 30 seconds.
# Python — basic retry-on-429 pattern
import time, requests
def geomind_get(path, params, api_key, retries=4):
headers = {"Authorization": f"Bearer {api_key}"}
delay = 2
for attempt in range(retries):
resp = requests.get(f"https://api.pixelapi.dev/v1/geomind{path}",
params=params, headers=headers)
if resp.status_code == 429:
time.sleep(delay)
delay = min(delay * 2, 30)
continue
resp.raise_for_status()
return resp.json()
raise RuntimeError("Rate limit not cleared after retries")
For bulk keyword audits above 600 rpm, email [email protected] with your expected volume. Higher limits are available on enterprise plans.
GEOmind is a REST API — you pay $0.001 per query with no monthly subscription. Semrush and similar tools charge $100–$400/month for platform access even if you only need a few data points. GEOmind gives you the same core rank data as a pay-per-call API you can embed directly in your product or pipeline.
Yes — new accounts get a 24-hour free trial with up to 5,000 queries at no cost and no credit card required. That is enough to run a full keyword audit across hundreds of pages. After the trial, credits are $10 per 10,000 queries ($0.001 each).
Send a GET request to /v1/geomind/competitor/displacement?keyword=your-keyword with your API key. The endpoint returns the top competing domains for that keyword, their current SERP positions, position changes since the last scan, and estimated traffic volumes in a single JSON response.
Citation velocity measures how quickly a keyword or topic is being cited across the web — in news articles, blog posts, and social media. A rising citation velocity often precedes a ranking shift. The /v1/geomind/citation/velocity endpoint returns 24-hour, 7-day, and 30-day citation counts plus the acceleration trend so you can act before competitors do.
For each keyword you query, the competitor displacement endpoint returns: domain name, current SERP position, position change (positive = moved up), and estimated organic traffic. You also get a displacement_alerts count flagging keywords where a competitor made a significant move.
GEOmind emits five alert types: rank_drop, rank_rise, competitor_new (a new domain entered the top 5), sentiment_spike, and citation_surge. Each alert includes the affected keyword, severity (high / medium / low), and a human-readable message. Poll GET /v1/geomind/alerts on a schedule or pipe it into Zapier, Make.com, or any webhook receiver.
GET /v1/geomind/sentiment?keyword=... returns an overall sentiment score (0–1), a bullish / bearish / neutral label, and breakdowns across news articles, social mentions, and blog posts — each with article counts, engagement rates, and a 7-day trend line.
POST /v1/geomind/scan/save stores a scan result (URL, keyword, score, grade) and returns a scan ID. GET /v1/geomind/scan/history retrieves your full scan log sorted by recency with scores and letter grades (A+, A, B+, B, C …) so you can build rank-over-time charts.
Default 60 requests/minute on the free tier, 600 requests/minute on paid tiers. Exceeding the limit returns HTTP 429 with a Retry-After header. For bulk keyword audits at higher throughput, email [email protected] with your expected volume.
The GEOmind endpoints are plain REST — any HTTP client works. Python users can use requests or httpx; Node users can use fetch or axios. The PixelAPI SDK (pip install pixelapi / npm install pixelapi) handles authentication and retry-on-429 automatically and can be used as a base for your own GEOmind wrapper.