REST API · Live

Keyword Position Tracker API Documentation

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.

$0.002 / call JSON responses 5,000 free credits (24-hour trial) No credit card Rank alerts included Citation velocity tracking
Get an API key (free) Quick start See pricing API docs

Quick start — track keyword positions in one API call

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)

Pricing — keyword position tracker API vs rivals

ProviderPricing modelPer-check costFree 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.

Keyword position tracker API — what you get back

Every endpoint returns clean JSON. Here are the key response shapes for each geomind-rank-tracker endpoint:

Competitor displacement

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.

Rank change alerts

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.

Scan history

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.

Citation velocity

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.

Keyword sentiment

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.

Agent protocol

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.

Common workflows for keyword position tracking

The geomind-rank-tracker API is the data layer behind these SEO and content-intelligence workflows:

Daily rank monitoring

Schedule a daily cron that calls /competitor/displacement for your target keywords and writes positions to a time-series store for dashboard visualization.

Rank-drop alerting

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.

Competitive gap analysis

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.

Trending keyword detection

Pair /citation/velocity with /sentiment: keywords with high 24h velocity and a bullish score are likely trending — invest in fresh content before competitors do.

SEO agency reporting

Use /scan/save to store weekly client rank snapshots and /scan/history to pull them into branded PDF reports — no dedicated reporting database required.

In-house SEO dashboards

Stream rank data into Google Sheets or Looker Studio via a lightweight scheduled function — one API key, no per-seat licensing, unlimited keywords tracked.

Content freshness scoring

Cross-reference citation velocity acceleration with page publish dates: pages with high citation velocity but old content dates are prime candidates for a refresh.

E-commerce category tracking

Track product-category keywords at scale — pull displacement data for 1,000+ keywords per day without per-seat dashboard costs typical of subscription tools.

Agent-based SEO pipelines

Use /agent/protocol to enumerate capabilities and /agent/command to orchestrate multi-step workflows from a Python or Node orchestrator script.

Integrations

Connect the keyword position tracker API to your existing SEO stack:

Zapier / Make.com

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.

Google Sheets

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.

Looker Studio / Data Studio

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.

Slack alerts

A 20-line Lambda polls /alerts and POSTs rank-drop notifications to your #seo Slack channel, including keyword, old position, new position, and severity.

GitHub Actions

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.

Python / Jupyter

Fetch multi-keyword position data into a pandas DataFrame for ad-hoc analysis, correlation with traffic, or cohort-based content experiments in notebooks.

Comparison vs alternatives

vs SEMrush

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.

vs Ahrefs

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.

vs SerpWatch

$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.

vs AccuRanker

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 & error handling

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 statusCodeMeaning
401unauthorizedMissing or invalid API key in the Authorization header
402trial_ended_subscribeFree trial credits exhausted — upgrade to a paid plan at pixelapi.dev/pricing
422validation_errorMissing required query parameter (e.g. keyword is required for /displacement and /sentiment)
429rate_limit_exceededToo many requests — back off and retry after the Retry-After header value (seconds)
500server_errorTransient error — retry with exponential backoff; contact support if it persists

Frequently asked questions — keyword position tracker API

What is the keyword position tracker API?

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.

How do I track keyword rankings via API?

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.

What does the keyword position tracker API cost?

$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.

What data does the competitor displacement endpoint return?

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.

How do rank change alerts work?

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.

Can I save and retrieve scan history?

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.

What is citation velocity tracking?

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.

Does the API support keyword sentiment analysis?

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.

Is there a Python SDK for the keyword position tracker API?

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.

What are the rate limits for the rank tracker API?

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.

Can I get an invoice for API usage?

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.

Start free — 5,000 credits, no card Read full API docs Compare all plans