# ASO Rank Tracker · App Store & Google Play Keyword Rankings (`sauliusautomatesit/aso-rank-tracker`) Actor

Track where your apps and competitors rank for keywords in the Apple App Store and Google Play. Keyword rank tracking, top apps per keyword, and app metadata. Schedule for daily ASO monitoring.

- **URL**: https://apify.com/sauliusautomatesit/aso-rank-tracker.md
- **Developed by:** [Saulius Saulenas](https://apify.com/sauliusautomatesit) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ASO Rank Tracker · App Store & Google Play Keyword Rankings

Track exactly where your apps — and your competitors' — rank for any keyword in the **Apple App Store**
and **Google Play**, in any country. Built for App Store Optimization (ASO): keyword rank tracking, top
apps per keyword, and app metadata. **No API key, no monthly seat fees.** Schedule it for daily rank
monitoring and pay only for the results you get.

The pay-as-you-go, API-first alternative to AppTweak, MobileAction and AppFollow.

### Why this actor

- **Both stores in one run** — Apple App Store and Google Play, side by side, with automatic store
  detection from the app ID.
- **Keyword rank tracking** — give it your keywords and your apps; get each app's exact rank position
  per keyword, per store, per country. Schedule it and build a rank-over-time history.
- **Competitor discovery** — `top_apps` mode returns the top-ranking apps for each keyword, so you see
  who owns a search term.
- **App metadata** — ratings, developer, price, genre, version and more.
- **Country-specific** — rankings differ by storefront; query `us`, `gb`, `de`, `jp`, and beyond.
- **Monitoring-native** — designed to be scheduled; every run is a timestamped snapshot.
- **No cookies, no login.**

### Use cases

| You are a… | You use it to… |
|---|---|
| App developer / publisher | Track your keyword rankings and watch competitors |
| ASO / mobile-marketing agency | Produce client keyword-rank reports across both stores |
| Growth / product manager | Measure the ASO impact of a listing change over time |
| Data / automation team | Feed an ASO dashboard via the Apify API on a schedule |

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | string | `keyword_rank`, `top_apps`, or `app_details`. |
| `keywords` | array | Search terms to check (keyword\_rank & top\_apps). |
| `apps` | array | Apps to track/fetch. App Store = numeric ID (`571800810`); Play = package (`com.calm.android`). |
| `stores` | array | `appstore`, `googleplay`, or both. |
| `country` | string | Storefront country code (`us`, `gb`, `de`, `jp`…). |
| `language` | string | Language for Google Play. |
| `maxResultsPerKeyword` | integer | How deep to scan (also the deepest detectable rank). |
| `proxyConfiguration` | object | Apify Proxy with the matching country recommended. |

#### Example — track your apps' rankings

```json
{
  "mode": "keyword_rank",
  "keywords": ["meditation", "sleep sounds", "breathing exercises"],
  "apps": ["571800810", "com.calm.android"],
  "stores": ["appstore", "googleplay"],
  "country": "us"
}
```

#### Example — who ranks for a keyword

```json
{ "mode": "top_apps", "keywords": ["budget tracker"], "stores": ["appstore"], "country": "us", "maxResultsPerKeyword": 25 }
```

### Output

**keyword\_rank** item — one per app × keyword × store:

```json
{
  "mode": "keyword_rank", "store": "appstore", "keyword": "meditation", "country": "us",
  "appId": "571800810", "appName": "Calm", "rank": 3, "found": true,
  "resultsChecked": 47, "topApp": { "appId": "337472899", "name": "Insight Timer", "rank": 1 },
  "scrapedAt": "2026-08-13T18:40:00.000Z"
}
```

`rank` is the app's position for that keyword (`null` + `found: false` if it isn't in the top
`maxResultsPerKeyword`). **top\_apps** items list each top-ranking app (`rank`, `appId`, `name`, `url`).
**app\_details** items carry metadata (`name`, `developer`, `rating`, `ratingCount`, `price`, `genre`,
`version`, `url`, …).

A run **summary** is saved to the key-value store under `SUMMARY`.

### Pricing

Pay-per-event: charged per **result** — one rank data point (app × keyword × store), one top-app row,
or one app-metadata record — plus a small per-run start fee. No subscription, no seats. Perfect for
scheduled daily tracking where you pay for exactly the data points you collect. See the Pricing tab.

### FAQ

**Where do the app IDs come from?** App Store: the numeric ID in the app's URL
(`apps.apple.com/app/id571800810` → `571800810`). Google Play: the package name in the URL
(`play.google.com/store/apps/details?id=com.calm.android` → `com.calm.android`). Run `top_apps` first
to discover IDs for a keyword.

**How is rank determined?** From each store's public keyword search results order for that country —
the same signal ASO tools use. Scan depth is set by `maxResultsPerKeyword`.

**Can I track rank over time?** Yes — schedule the actor; each run appends timestamped snapshots you can
chart.

**Which is more detailed?** App Store search returns rich metadata (rating, developer, price) inline;
Google Play returns ranked packages (use `app_details` or `top_apps` for names/ratings).

### Limitations

- Reflects public store **search** rankings, which approximate (and closely track) the in-app ranking;
  featured/editorial placements aren't search results.
- Google Play search returns ~30–50 results per keyword; set `maxResultsPerKeyword` accordingly.
- Use Apify Proxy with the target country for storefront-accurate results.

# Actor input Schema

## `mode` (type: `string`):

`keyword_rank` = where your listed apps rank for each keyword (tracking); `top_apps` = the top-ranking apps for each keyword (competitor/market discovery); `app_details` = metadata for specific apps.

## `keywords` (type: `array`):

Search terms to check rankings for (e.g. `meditation`, `budget tracker`, `photo editor`). Used by keyword\_rank and top\_apps.

## `apps` (type: `array`):

App identifiers to track (keyword\_rank) or fetch (app\_details). App Store apps = numeric ID (e.g. `571800810` for Calm); Google Play apps = package name (e.g. `com.calm.android`). The store is detected automatically from the ID format.

## `stores` (type: `array`):

Which app stores to query.

## `country` (type: `string`):

Two-letter country code for the store storefront (e.g. `us`, `gb`, `de`, `jp`). Rankings are country-specific.

## `language` (type: `string`):

Two-letter language code for Google Play results/metadata.

## `maxResultsPerKeyword` (type: `integer`):

How deep to scan the search results (also the deepest rank detectable). 50 covers the meaningful ASO positions.

## `concurrency` (type: `integer`):

Parallel store searches.

## `proxyConfiguration` (type: `object`):

Proxy settings. Apify Proxy with the matching country is recommended so rankings reflect that storefront.

## Actor input object example

```json
{
  "mode": "keyword_rank",
  "keywords": [
    "meditation",
    "sleep sounds"
  ],
  "apps": [
    "571800810",
    "com.calm.android"
  ],
  "stores": [
    "appstore",
    "googleplay"
  ],
  "country": "us",
  "language": "en",
  "maxResultsPerKeyword": 50,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rankings` (type: `string`):

keyword\_rank: one item per tracked app × keyword × store with its rank position (or not-found). top\_apps: one item per top-ranking app per keyword. app\_details: one item per app with metadata. Schedule the run to build a rank-over-time history.

## `summary` (type: `string`):

A JSON report: mode, keywords, apps, stores, searches performed, rows returned, errors, and whether the run stopped at your maximum charge limit.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "meditation",
        "sleep sounds"
    ],
    "apps": [
        "571800810",
        "com.calm.android"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sauliusautomatesit/aso-rank-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "meditation",
        "sleep sounds",
    ],
    "apps": [
        "571800810",
        "com.calm.android",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("sauliusautomatesit/aso-rank-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "meditation",
    "sleep sounds"
  ],
  "apps": [
    "571800810",
    "com.calm.android"
  ]
}' |
apify call sauliusautomatesit/aso-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sauliusautomatesit/aso-rank-tracker"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XeiLUh9JooeUcgQEq/builds/XyXxfkDjmHO5Cd7gh/openapi.json