The keyword position tracker API (geomind-rank-tracker) lets you programmatically check SERP rankings for any keyword, monitor competitor positions, receive rank change alerts, and measure citation velocity — all from a single REST endpoint. $0.002 per call — lower than SerpWatch's public per-check rate. 5,000 free credits (24-hour trial), no credit card.
Sign up, copy your key from the dashboard, and call the competitor displacement endpoint with your target keyword. You get back a structured JSON list of domains, their current SERP positions, position deltas, and estimated organic traffic. No SDK required — a plain HTTP GET is enough.
# Track keyword positions
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-10-09T01:00:00Z",
# "competitors": [
# {"domain": "semrush.com", "position": 1, "change": 0, "estimated_traffic": 42500},
# {"domain": "ahrefs.com", "position": 2, "change": 1, "estimated_traffic": 38200},
# {"domain": "moz.com", "position": 3, "change": -1, "estimated_traffic": 29100}
# ],
# "total_competitors": 5,
# "displacement_alerts": 2
# }
# Get active rank change alerts
curl "https://api.pixelapi.dev/v1/geomind/alerts" \
-H "Authorization: Bearer YOUR_API_KEY"
pip install pixelapi
---
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
# Check keyword positions
result = client.geomind.competitor_displacement(keyword="seo rank tracker")
for c in result["competitors"]:
print(c["domain"], c["position"], c["change"])
# Save a rank scan snapshot
client.geomind.scan_save(url="mysite.com", keyword="seo rank tracker", score=82, grade="A")
# Retrieve full scan history
history = client.geomind.scan_history()
print(history["scans"])
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
// Track keyword positions
const result = await client.geomind.competitorDisplacement({ keyword: "seo rank tracker" });
result.competitors.forEach(c =>
console.log(`${c.domain}: #${c.position} (${c.change >= 0 ? "+" : ""}${c.change})`)
);
// Get alerts for rank drops and rises
const alerts = await client.geomind.alerts();
const drops = alerts.alerts.filter(a => a.type === "rank_drop" && a.severity === "high");
console.log(`${drops.length} high-severity rank drop alerts`);
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;
$client = new Client(getenv("PIXELAPI_KEY"));
// Track keyword positions
$result = $client->geomind->competitorDisplacement(["keyword" => "seo rank tracker"]);
foreach ($result["competitors"] as $c) {
echo "{$c['domain']} — position {$c['position']} (delta: {$c['change']})\n";
}
// Get citation velocity
$velocity = $client->geomind->citationVelocity(["keyword" => "seo rank tracker"]);
echo "Citations in last 24h: {$velocity['velocity_24h']}\n";
echo "7-day acceleration: {$velocity['acceleration']}\n";
gem install pixelapi
---
require "pixelapi"
client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
# Track keyword positions
result = client.geomind.competitor_displacement(keyword: "seo rank tracker")
result["competitors"].each do |c|
puts "#{c['domain']}: ##{c['position']} (change: #{c['change']})"
end
# Save a rank scan
client.geomind.scan_save(
url: "mysite.com",
keyword: "seo rank tracker",
score: 82,
grade: "A"
)
go get github.com/pixelapi/pixelapi-go
---
import (
"fmt"
pixelapi "github.com/pixelapi/pixelapi-go"
)
client := pixelapi.New("YOUR_API_KEY")
// Track keyword positions
result, err := client.Geomind.CompetitorDisplacement("seo rank tracker")
if err != nil { panic(err) }
for _, c := range result.Competitors {
fmt.Printf("%s: position %d (change %+d)\n", c.Domain, c.Position, c.Change)
}
// Get rank alerts
alerts, err := client.Geomind.Alerts()
if err != nil { panic(err) }
fmt.Printf("%d active alerts (%d total)\n", alerts.ActiveAlerts, alerts.TotalAlerts)
| Provider | Pricing model | Per-check cost | Free tier |
|---|---|---|---|
| PixelAPI geomind-rank-tracker | Pay per API call | $0.002 / call | 5,000 credits (24-hour trial), no card |
| SerpWatch | Subscription — keyword checks/month | ~$0.0039/check (annual Starter: $29/mo ÷ 7,500 checks) | 14-day money-back guarantee |
| AccuRanker | Subscription — keywords tracked/month | See accuranker.com/pricing | No free tier listed publicly |
| SEMrush API | Add-on to subscription plan | See developer.semrush.com | Limited free API rows on paid plan |
| Ahrefs API | Subscription add-on | See docs.ahrefs.com | See ahrefs.com/pricing |
Pricing verified from each rival's public pricing page in October 2026. SerpWatch rate calculated from annual Starter plan ($29/month ÷ 7,500 checks = $0.0039/check). AccuRanker, SEMrush, and Ahrefs API costs require a subscription or sales contact and do not publish a simple per-call rate. PixelAPI's price is set at exactly half of SerpWatch's public per-check rate per our standing pricing rule.
Every endpoint returns clean JSON. Here are the key response shapes for each geomind-rank-tracker endpoint:
GET /v1/geomind/competitor/displacement?keyword=...
Returns competitors array: domain, position (1–100), position change delta vs prior scan, and estimated organic traffic. Also includes total_competitors count, displacement_alerts count, and scan timestamp.
GET /v1/geomind/alerts
Returns total_alerts, active_alerts, and an alerts array. Alert types: rank_drop, rank_rise, competitor_new, sentiment_spike, citation_surge. Each alert includes severity (low/medium/high), keyword, message, and timestamp.
GET /v1/geomind/scan/history — returns total_scans count and a scans array: id, url, keyword, numeric score, letter grade (A+/A/B+/B/C), and ISO timestamp.POST /v1/geomind/scan/save — persist your own rank measurement with url, keyword, score, and grade. Returns the assigned scan_id.
GET /v1/geomind/citation/velocity?keyword=...
Returns total_citations, velocity windows (velocity_24h, velocity_7d, velocity_30d), a 7-day trend array, acceleration score, and top_citing_sources with first-seen dates.
GET /v1/geomind/sentiment?keyword=...
Returns overall rating (bullish/bearish/neutral), 0–1 score, and per-source breakdowns: news (24h article count, avg impact), social (24h mention count, engagement rate), and blogs (24h post count, avg authority). Includes a 7-day trend_7d array and top_sentiments with source headlines.
GET /v1/geomind/agent/protocol
Returns the agent's capabilities list (geo_scan, competitor_analysis, sentiment_tracking, citation_tracking, alert_management, keyword_discovery), status, and a full endpoints map — useful for orchestration pipelines that need to discover available operations at runtime.
The geomind-rank-tracker API is the data layer behind these SEO and content-intelligence workflows:
Schedule a daily cron that calls /competitor/displacement for your target keywords and writes positions to a time-series store for dashboard visualization.
Poll /alerts every hour; filter for type=rank_drop and severity=high; fire Slack or PagerDuty notifications when a key page drops more than 3 positions overnight.
Compare competitor positions across a keyword set to find gaps where rivals rank #1–#3 but your domain is outside the top 10 — then prioritize those pages for content updates.
Pair /citation/velocity with /sentiment: keywords with high 24h velocity and a bullish score are likely trending — invest in fresh content before competitors do.
Use /scan/save to store weekly client rank snapshots and /scan/history to pull them into branded PDF reports — no dedicated reporting database required.
Stream rank data into Google Sheets or Looker Studio via a lightweight scheduled function — one API key, no per-seat licensing, unlimited keywords tracked.
Cross-reference citation velocity acceleration with page publish dates: pages with high citation velocity but old content dates are prime candidates for a refresh.
Track product-category keywords at scale — pull displacement data for 1,000+ keywords per day without per-seat dashboard costs typical of subscription tools.
Use /agent/protocol to enumerate capabilities and /agent/command to orchestrate multi-step workflows from a Python or Node orchestrator script.
Connect the keyword position tracker API to your existing SEO stack:
Use the PixelAPI HTTP action in Zapier or Make to schedule keyword rank checks and push results into Google Sheets, Airtable, Notion, or your CRM automatically — no custom code.
A 30-line Apps Script function calling the displacement endpoint populates a sheet with daily position history. Free, no extra tooling, shareable with clients instantly.
Write rank data to BigQuery via a daily Cloud Function, then connect Looker Studio for live charts. Full position history with no per-seat dashboard fees.
A 20-line Lambda polls /alerts and POSTs rank-drop notifications to your #seo Slack channel, including keyword, old position, new position, and severity.
Add a rank-check workflow that runs on push to content branches — fail the deploy if target keywords drop below a defined threshold, surfacing regressions before they go live.
Fetch multi-keyword position data into a pandas DataFrame for ad-hoc analysis, correlation with traffic, or cohort-based content experiments in notebooks.
Pay per API call, not a $117–$417+/month subscription. No seat limits. Free trial with 5,000 credits — no sales call, no credit card. Full JSON access to rank data from day one.
Same structured keyword rank data via REST. Transparent $0.002/call pricing vs an opaque API add-on cost. Suitable for developers who need programmatic access without a full Ahrefs subscription.
$0.002/call vs $0.0039/check minimum (SerpWatch annual Starter). No monthly subscription required — pay only for calls made, ideal for burst usage or sporadic rank checks that don't justify a monthly seat fee.
AccuRanker requires a minimum ~$224/month plan for 2,000 tracked keywords. PixelAPI has no monthly minimum — 1,000 rank checks costs $2.00. See pixelapi.dev/pricing for full plan comparison.
Rate limits by plan: 20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale. 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. The Python and Node SDKs handle this automatically.
# Python SDK auto-retries 429 with backoff from pixelapi import PixelAPI client = PixelAPI(api_key="...", max_retries=4) # Auto-retries on 429 — no manual retry loop needed result = client.geomind.competitor_displacement(keyword="seo rank tracker")
Common error responses:
| HTTP status | Code | Meaning |
|---|---|---|
| 401 | unauthorized | Missing or invalid API key in the Authorization header |
| 402 | trial_ended_subscribe | Free trial credits exhausted — upgrade to a paid plan at pixelapi.dev/pricing |
| 422 | validation_error | Missing required query parameter (e.g. keyword is required for /displacement and /sentiment) |
| 429 | rate_limit_exceeded | Too many requests — back off and retry after the Retry-After header value (seconds) |
| 500 | server_error | Transient error — retry with exponential backoff; contact support if it persists |
The geomind-rank-tracker API lets you check SERP keyword positions, monitor competitor displacement, receive rank change alerts, track citation velocity, and analyze keyword sentiment — all via REST calls with your PixelAPI key. It replaces manual dashboard checks in SemRush or Ahrefs with a programmable, pay-per-call data feed.
Send GET https://api.pixelapi.dev/v1/geomind/competitor/displacement?keyword=your+keyword with Authorization: Bearer YOUR_API_KEY. The response includes a competitors array: each entry has domain, position (1–100), change delta vs prior scan, and estimated_traffic. See the Quick Start section above for code in 6 languages.
$0.002 per call — lower than SerpWatch's $0.0039/check (annual Starter plan, October 2026 pricing). New accounts get 5,000 free credits (24-hour trial) with no credit card required — enough for 2,500 rank checks before paying anything.
The /v1/geomind/competitor/displacement endpoint returns the queried keyword, scanned_at timestamp, and a competitors array. Each competitor has: domain, position (integer 1–100), change delta (positive = rose, negative = dropped), and estimated_traffic. Top-level fields also include total_competitors and displacement_alerts count.
GET /v1/geomind/alerts returns all active alerts for your tracked keywords. Alert types: rank_drop, rank_rise, competitor_new (a new domain entering the top 5), sentiment_spike, and citation_surge. Each alert carries type, severity (low/medium/high), keyword, a human-readable message, and an ISO timestamp.
Yes. POST /v1/geomind/scan/save with JSON body {"url":"mysite.com","keyword":"seo rank tracker","score":82,"grade":"A"} persists a rank snapshot and returns a scan_id. Retrieve all saved scans via GET /v1/geomind/scan/history, which returns a list sorted by most recent timestamp.
GET /v1/geomind/citation/velocity?keyword=... shows how fast a keyword is being cited across news, blogs, and social media. Response includes 24h, 7d, and 30d velocity windows, a 7-day trend array, an acceleration score (useful for spotting trending topics), and the top citing domains with first-seen dates.
GET /v1/geomind/sentiment?keyword=... returns overall rating (bullish/bearish/neutral), a 0–1 score, and per-source breakdowns: news (24h article count, avg impact score), social (24h mention count, engagement rate), and blogs (24h post count, avg domain authority). Also includes a 7-day trend_7d array and top_sentiments with source names and headlines.
Yes — pip install pixelapi. Official SDKs also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), Go (go get), and Java/Kotlin. All SDKs handle authentication, 429 retry with exponential backoff, and response deserialization automatically.
20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale. Exceeding the limit returns HTTP 429 with a Retry-After header. Higher limits for large-scale rank monitoring pipelines — email support@pixelapi.dev with your expected call volume.
Yes. PixelAPI is a registered Indian business. We issue GST invoices — 18% IGST for international clients, CGST/SGST for domestic. Invoice download is built into the dashboard at pixelapi.dev/app.