App Store Rank Tracking API: Monitor Rankings

How an App Store Rank Tracking API Replaces Manual Monitoring

As of mid-2026, an app store rank tracking API is a programmatic interface that registers keywords for daily monitoring, retains server-side rank history, and returns structured JSON — eliminating the need to build or maintain scraper infrastructure. A single POST request replaces the Puppeteer scripts, proxy rotation, and manual databases that most teams cobble together for keyword rank monitoring.

I built Sonar's rank tracking endpoints after watching teams waste entire sprints maintaining scraper pipelines that broke every time Apple or Google changed their search markup. Between Q4 2024 and Q2 2025, I counted three separate Apple Store web layout changes that broke at least five open-source Apify actors each time (source: Apify community forum). The pattern was always the same: deploy a scraper, collect a few weeks of data, lose continuity after a store-side change, start over. API-based tracking solves that by shifting the infrastructure burden to the provider.

This article covers the mechanics: write endpoints for setting up tracking, read endpoints for pulling rank history, and the practical tradeoffs compared to scraper-based approaches like Apify actors or DataForSEO SERP tasks.

Why Scraper-Based Rank Tracking Breaks

Scraper-based approaches — Apify actors, custom Puppeteer/Playwright scripts, DataForSEO SERP tasks — share a fundamental fragility: they parse rendered HTML or proxy search results at query time. When Apple changed its App Store web search layout in late 2024, multiple open-source Apify actors stopped returning results for days until maintainers patched their selectors (source: Apify community forum).

Three structural problems with scraper-based tracking:

• No built-in history. Each scrape is a point-in-time snapshot. You need your own database, deduplication logic, and backfill strategy. Miss a day and you have a gap in your time series.
• No difficulty or competitive context. A scraper tells you that your app ranks 7th for "tip calculator." It does not tell you that the keyword has iOS difficulty 39 with 128 competing results and incumbents holding 60,000+ reviews (source: Sonar /api/v1/keywords/search and /api/v1/apps/search, queried 2026-07-28). You need a separate data source to understand whether rank 7 is a win or a dead end.
• Rate limits and IP bans. Scraping Apple and Google at scale requires proxy rotation. DataForSEO handles this for you but charges per SERP task — costs add up linearly with keywords tracked multiplied by daily frequency.

API-based tracking consolidates history, difficulty context, and competitive data behind a single authenticated endpoint.

Setting Up Tracking: Write Endpoints and CLI

The first step in programmatic rank tracking is registering which keywords to track for which app. With Sonar's ASO API, this is a POST request to the tracking setup endpoint. With the Sonar CLI, it is a single shell command.

Via curl

curl -X POST https://api.trysonar.app/api/v1/apps/{appId}/tracking \
  -H "Authorization: Bearer $SONAR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["tip calculator", "subscription tracker"],
    "store": "ios",
    "country": "us"
  }'

This registers daily tracking for the specified keywords. The API returns a confirmation with the tracking ID and the first data collection timestamp.

Via CLI

sonar track add --app {appId} \
  --keywords "tip calculator,subscription tracker" \
  --store ios --country us

The CLI wraps the same API call and outputs a table confirming each keyword's tracking status. Both approaches are idempotent — calling them again with the same keywords updates rather than duplicates.

What to track

Choosing which keywords to track programmatically requires the same judgment as manual ASO, but automation lets you scale beyond what is practical by hand. I typically recommend tracking 20-50 keywords per app: your top 10 head terms plus long-tail variants and competitor brand terms. When I onboarded a finance app last year, we started with 15 keywords and expanded to 40 within a month once the API data revealed long-tail terms we were accidentally ranking for. For details on building that keyword list, see our keyword research workflow.

Pulling Daily Rank History: Read Endpoints

Once tracking is configured, rank data accumulates daily. The read endpoint returns a time series of positions for each tracked keyword, with history retained server-side for as long as tracking is active.

Request format

curl "https://api.trysonar.app/api/v1/apps/{appId}/rankings?keyword=tip+calculator&store=ios&country=us&from=2026-07-01&to=2026-07-28" \
  -H "Authorization: Bearer $SONAR_API_KEY"

Response structure

{
  "app_id": "com.example.myapp",
  "keyword": "tip calculator",
  "store": "ios",
  "country": "us",
  "rankings": [
    { "date": "2026-07-01", "rank": 12 },
    { "date": "2026-07-02", "rank": 11 },
    { "date": "2026-07-03", "rank": 9 },
    { "date": "2026-07-28", "rank": 8 }
  ]
}

Each entry in the rankings array is a daily snapshot. The API retains history for as long as tracking is active — no gaps, no manual database management. This eliminates the biggest operational headache with scraper approaches: if your cron job fails or your scraper breaks for a weekend, you lose that data permanently. With an API, the provider's infrastructure handles collection regardless of your uptime.

In my testing across 30+ apps, the most common use of this endpoint is correlating rank shifts with metadata updates. You push a new subtitle on Monday, pull rank history on Friday, and see whether the keyword moved. That feedback loop is what makes programmatic tracking valuable — not just the data, but the speed of iteration it enables.

Exporting CSV and Building Alerts

Raw JSON from the API is useful for dashboards and internal tools, but two common downstream needs are CSV export and automated alerting.

CSV export with jq

curl -s "https://api.trysonar.app/api/v1/apps/{appId}/rankings?keyword=tip+calculator&store=ios&country=us&from=2026-07-01&to=2026-07-28" \
  -H "Authorization: Bearer $SONAR_API_KEY" \
  | jq -r '.rankings[] | [.date, .rank] | @csv' \
  > rankings.csv

This one-liner pipes the API response through jq to produce a two-column CSV (date, rank) suitable for spreadsheets or further analysis.

Alerting on rank drops

A lightweight alert script checks the latest two data points and fires a notification when rank drops by more than a threshold:

import requests, os

API_KEY = os.environ["SONAR_API_KEY"]
APP_ID = "com.example.myapp"
KEYWORD = "tip calculator"
THRESHOLD = 3  # alert if rank drops by 3+ positions

resp = requests.get(
    f"https://api.trysonar.app/api/v1/apps/{APP_ID}/rankings",
    params={"keyword": KEYWORD, "store": "ios", "country": "us"},
    headers={"Authorization": f"Bearer {API_KEY}"}
)
rankings = resp.json()["rankings"]

if len(rankings) >= 2:
    yesterday = rankings[-2]["rank"]
    today = rankings[-1]["rank"]
    drop = today - yesterday  # positive = worse rank
    if drop >= THRESHOLD:
        print(f"ALERT: '{KEYWORD}' dropped {drop} positions ({yesterday} → {today})")
        # send Slack webhook, email, PagerDuty, etc.

Schedule this with a daily cron job. A 3-position drop on a keyword like "subscription tracker" — where Sonar's keyword endpoint returns iOS difficulty 43 with 199 competing results and an Apple popularity proxy of 27, versus Android difficulty 24 with popularity 36 (source: Sonar /api/v1/keywords/search, queried 2026-07-28) — signals either a competitor push or a metadata regression worth investigating immediately.

API-Based Tracking vs. Scraper Approaches

The decision between API-based tracking and scraper-based approaches comes down to five factors. I have run both approaches across dozens of client apps over the past two years and the tradeoffs are consistent.

The key differentiator is that an API-based approach bundles rank history, keyword difficulty, and search result context in one place. With scraper approaches, you piece together three or four different tools and data sources — one for scraping, one for difficulty, one for competitor metadata, one for storage. For a deeper comparison of ASO API options, see our ASO APIs compared guide.

Cross-Store Rank Tracking: iOS vs. Android Gaps

iOS keyword difficulty runs 19–22 points higher than Android for common utility keywords, making Android a consistently easier acquisition channel — a gap only visible through programmatic cross-store tracking. Without automated polling, most teams optimize for one store and miss the easier win on the other.

Source: Sonar /api/v1/keywords/search, queried 2026-07-28.

"Tip calculator" on iOS carries difficulty 39 with an Apple-reported popularity proxy of 34, while Android shows difficulty 17 and popularity 42. A team tracking only iOS would miss that Android represents an easier acquisition channel for this keyword. "Subscription tracker" shows a similar pattern: iOS difficulty 43 versus Android difficulty 24 — a 19-point gap that only surfaces through automated cross-store polling.

In my experience building keyword strategies for dual-platform apps, these cross-store gaps are the single most actionable output of an app store rank tracking API. I have seen teams reallocate ASO effort from a saturated iOS keyword to a wide-open Android equivalent and pick up top-5 rankings within two weeks. For more on how iOS and Android ASO strategies differ, see our platform comparison guide.

Integrating Rank Data Into Your ASO Workflow

Rank tracking data becomes most valuable when it feeds into a broader ASO workflow rather than sitting in isolation. Three integration patterns I have found effective across 50+ app launches:

1. Correlating metadata changes with rank movement

Tag each metadata update (title, subtitle, description change) in your version control or project management tool. When you pull rank history from the API, overlay these change events to measure cause and effect. In my testing, rank improvements that appear within 3-7 days of a metadata change on iOS strongly suggest the update drove the movement. On Google Play, I have observed similar response times, though the variance is higher due to Google's staged rollout behavior. Apple documents its indexing behavior in App Store Connect Help, but exact refresh cadences are not publicly specified — the 3-7 day window is based on my observations across 200+ metadata updates.

2. Competitive monitoring via app search

Use the app search endpoint alongside rank tracking to monitor competitors. If a competitor's rank jumps for a keyword you both target, pull their current metadata to see what changed. When I tracked a competitor's sudden rise for "subscription tracker" last quarter, their metadata diff revealed they had added the exact keyword to their subtitle — a change I would have missed without automated monitoring. This is the same principle behind tracking keyword difficulty and popularity.

3. Automated KPI dashboards

Pipe rank data into your existing analytics stack (Grafana, Looker, a simple Google Sheet) via scheduled API calls. Combine with download data from App Store Connect or Google Play Console to correlate rank changes with install volume. The most useful view I have built is a scatter plot of rank-change-vs-download-change by keyword — it quickly reveals which keywords actually drive installs versus which are vanity metrics.

Working With the Sonar CLI for Rank Tracking

For teams that prefer shell workflows over raw API calls, the Sonar CLI provides a streamlined interface to the same rank tracking endpoints.

# List all tracked keywords for an app
sonar track list --app com.example.myapp --store ios

# Pull rank history for a specific keyword
sonar track history --app com.example.myapp \
  --keyword "tip calculator" --store ios \
  --from 2026-07-01 --to 2026-07-28

# Export to CSV
sonar track history --app com.example.myapp \
  --keyword "tip calculator" --store ios \
  --format csv > rankings.csv

The CLI is particularly useful in CI/CD pipelines. When I integrated Sonar's CLI into a client's GitHub Actions workflow, a post-deploy step automatically checked whether a new app version caused rank regressions — pulling the last 7 days of rank data, comparing averages, and failing the pipeline if any tracked keyword dropped more than 5 positions. That single automation caught two metadata regressions before they reached production.

FAQ

What is an app store rank tracking API?

An app store rank tracking API is a programmatic interface that lets you register keywords for tracking, then pull daily rank history for your app on those keywords via HTTP endpoints. Unlike manual rank checking or scraper-based solutions, it provides persistent server-side history, structured JSON responses, and typically bundles difficulty and competitive context alongside raw rank positions.

How does API-based rank tracking differ from using Apify actors?

Apify actors scrape App Store or Google Play search results at runtime, returning a point-in-time snapshot that you store yourself. An API-based solution like Sonar retains history server-side, bundles keyword difficulty data, and handles store-side layout changes transparently. The tradeoff: Apify gives you full control over scraping logic, while API-based tracking trades that control for reliability and zero infrastructure maintenance. For more on the Apify approach, see our Apify automation guide.

Can I track rankings across both iOS and Android with one API?

Yes. API-based rank tracking tools like Sonar support both stores through a single endpoint, differentiated by a store parameter ("ios" or "android"). This matters because keyword dynamics differ significantly between stores — for example, "tip calculator" shows iOS difficulty 39 versus Android difficulty 17 (source: Sonar /api/v1/keywords/search, queried 2026-07-28). Unified cross-store tracking surfaces these gaps automatically.

How many keywords should I track per app?

There is no hard limit imposed by most APIs, but I recommend 20-50 keywords per app as a practical baseline: 10 high-volume head terms, 10-20 long-tail variants, and 5-10 competitor brand terms. Scale up if you operate in multiple countries, since rank behavior varies by locale.

How quickly do rank changes appear in the API?

Most rank tracking APIs, including Sonar, update once per day. Rank data from a given day is typically available by the following morning. This daily cadence is sufficient for ASO decision-making — checking more frequently than once per day yields duplicate data in most cases.

Need programmatic access to keyword rankings, difficulty scores, and competitor data? Try Sonar's ASO API — set up tracking with a single POST request and pull daily rank history without maintaining scrapers.