# ASO Keyword Research: Keywords Any App Ranks For, iOS & Android (`vncntlabs/aso-keyword-research`) Actor

Paste an App Store id or Google Play package and get every keyword that app ranks for, with estimated volume (DataForSEO), rank, a last-checked date, an opportunity score, and a ready-to-paste iOS keyword field. Gap mode compares you with up to 5 competitors. No API key needed.

- **URL**: https://apify.com/vncntlabs/aso-keyword-research.md
- **Developed by:** [VNCNT Labs](https://apify.com/vncntlabs) (community)
- **Categories:** SEO tools, Developer tools, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ranked keywords

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ASO Keyword Research: Keywords Any App Ranks For, iOS & Android

Paste an App Store id or a Google Play package. You get every keyword that app ranks for, with **estimated volume (DataForSEO)**, rank, the date that rank was last checked, an opportunity score, and a ready-to-paste iOS keyword field (or a list of Android description terms).

Add up to 5 competitor apps and you also get a gap table: keywords they rank for and you don't (`gap`), keywords where they beat you (`behind`), and keywords where you are ahead.

A third mode lists the apps that compete with you on the same keywords.

Failed lookups, unknown app ids and apps with no data are **never charged** (start fee only).

### Who it's for

- **Indie iOS and Android developers:** find out which keywords your app, or the app beating you, actually ranks for, and which words to put in the App Store keyword field tonight.
- **Small ASO agencies:** one run per client app, with a scored gap table you can hand over.

This Actor does not need a keyword list you already know. The app goes in; the keywords come out.

### What you get

- One **listing** row first: a ready-to-paste iOS keyword field (at most 100 characters, comma-separated, no spaces) and, for Android, a list of terms to work into the short and long description.
- One **keyword** row per term, sorted by opportunity score: `estimatedVolume` (labeled estimated volume (DataForSEO)), `yourRank`, `lastChecked`, `ageDays`, `opportunityScore`, and a `noiseFlag` column.
- In gap mode, each keyword is labeled `gap`, `behind` or `ahead`, with both ranks.
- In discovery mode, one row per competing app: shared keyword count, their keyword count, summed estimated volume, average position, and position-band counts. DataForSEO's competitor list does not include app titles; we pass through the app id and a store URL.
- An optional live rank on the top N scored, non-flagged keywords, when you turn that on.

Volume is **DataForSEO's monthly estimate**. It is not Apple popularity and it is not a live rank. Every row carries the date DataForSEO last checked that rank (often 1 to 8 weeks old). US English store only.

### Opportunity score

Rows are sorted by this score, then by estimated volume. The formula is published here and is plain arithmetic, no model:

```
freshness = max(0.30, 1 - age_days / 90)
    age_days is whole days between lastChecked and now (UTC).
    If lastChecked is missing, freshness is 0.30.

weakness:
    gap    (you have no rank in DataForSEO's top 100):  competitor_rank / 100
    behind (you rank, they rank higher):               ((your_rank - competitor_rank) / 100) * (competitor_rank / 100)
    ahead  (you already rank higher):                  0
    ranked (app-keywords mode, no competitor):         0 if rank == 1 else rank / 100

opportunity_score = estimated_volume * weakness * freshness
```

A weaker competitor rank (for example #20 vs #1) raises the score. Older rows are lowered. Missing volume is treated as 0.

### Relevance gate and the listing builder

A row is flagged in `noiseFlag` when the keyword shares no word (including simple singular and plural forms) with the app's own metadata.

We first load DataForSEO App Data `app_info`. For the App Store that returns title, subtitle and description. For Google Play it returns title, description and tags, and no separate subtitle or short-description field. If that call fails or times out, we fall back to title-only matching using the title on the keyword rows, and we say so in `metadataSource`.

Flagged rows stay in the dataset so you can inspect them. They are kept out of the iOS keyword field and the Android term list.

The iOS field packs the best-scoring gap, behind or ranked words that are not already in the title or subtitle, comma-separated with no spaces, and stops at 100 characters. Duplicate singular and plural forms are dropped. For Android we return the same terms as a list, because Play has no 100-character keyword field: work them into the short and long description.

### Input

| Field | What it does |
| --- | --- |
| `app` | App Store id or URL, or Google Play package or URL. Required. |
| `store` | `auto` (default), `app_store` or `google_play`. |
| `mode` | `app_keywords` (default), `gap` or `discovery`. |
| `competitors` | Up to 5 competitor ids, packages or URLs. Required for gap mode. |
| `limit` | Keyword rows to return (or competitor rows in discovery). Default 100, max 1,000. Gap mode always requests at least 20 keywords per competitor. |
| `minVolume` | Optional floor on estimated volume (DataForSEO). Default 0. |
| `maxRank` | Optional cap on your rank in app-keywords mode (1 is best, 100 is the floor DataForSEO stores). |
| `competitorRankMax` | In gap mode, only pull competitor keywords where they rank at or above this position. Default 20. |
| `liveCheckTopN` | Optional. Live-check the top N non-flagged keywords in App Store or Play search. Default 0 (off). Max 20. |

```json
{
  "app": "571800810",
  "store": "app_store",
  "mode": "app_keywords",
  "limit": 20
}
```

The prefilled input (Calm's App Store id, 20 keywords, no live check) is sized to finish well inside 5 minutes. DataForSEO Labs usually answers in 1 to 3 seconds; app info uses the standard queue with a 60-second priority hedge.

### Output

The first dataset row is the listing change. Keyword rows follow, already sorted by opportunity score. This one is from a real run on 13 Nov 2026 (America/New_York) for Calm (`571800810`) on the App Store, limit 20, no live check (run `uxDuBQusRdK13vgv2`). Ranks and estimated volume will move as DataForSEO refreshes them; a later run will not match these numbers exactly.

```json
{
  "type": "listing",
  "store": "app_store",
  "appId": "571800810",
  "appTitle": "Calm",
  "subtitle": "Sleep, Meditation, Relaxation",
  "iosKeywordField": "rain,sounds,music,calming,machine,soft,mindfulness,app",
  "charactersUsed": 54,
  "androidTerms": ["rain sounds", "sleep", "sleep music", "relaxation music", "calming music", "sound machine", "soft music", "mindfulness", "meditation", "calm app", "calm"],
  "metadataSource": "app_info"
}
```

A keyword row from the same run:

```json
{
  "type": "keyword",
  "keyword": "rain sounds",
  "estimatedVolume": 3813,
  "volumeSource": "estimated volume (DataForSEO)",
  "yourRank": 8,
  "relation": "ranked",
  "opportunityScore": 284.704,
  "lastChecked": "2026-11-07T02:58:44Z",
  "ageDays": 6,
  "noiseFlag": false,
  "resultsCount": 250
}
```

Rows such as "coolgames" or "a lm" were flagged in `noiseFlag` because they share no word with Calm's title, subtitle or description, and they were kept out of the keyword field.

### Live rank check (opt-in)

DataForSEO's App Data search endpoint can look up the current App Store or Google Play results for a keyword. Standard queue is $0.0012 per request (up to 100 App Store results, or 30 on Google Play) and can take a while; priority is $0.0024 and is used as a 60-second hedge, the same pattern as our other queued Actors. The queue wait is capped so a stall ends as a clear, uncharged miss instead of a platform timeout.

When `liveCheckTopN` is greater than 0, we live-check that many top-scoring, non-flagged keywords and write `liveRank`, `liveCheckedAt` and `liveRankDelta` (your Labs rank minus the live rank; positive means you improved). This is billed as `live-rank-check` at $0.02 per successful keyword, an amount we already charge on other tools. Failed checks are free. Leave this at 0 unless you need a live confirmation; the default rows already show the Labs last-checked date.

### Pricing

Pay per event, after Apify's start fee. Prices below are live amounts we already charge on other tools.

| Event | Price | When it is charged |
| --- | --- | --- |
| Actor start | $0.005 | Once per run (Apify's platform fee) |
| `app-lookup` | $0.02 | Each successful app keyword pull, or one competitor-discovery lookup |
| `ranked-keyword` | $0.001 | Each keyword row delivered (any mode) |
| `competitor-compared` | $0.03 | Each competitor whose keywords were pulled in gap mode |
| `competitor-app` | $0.004 | Each competing app row in discovery mode |
| `live-rank-check` | $0.02 | Each keyword successfully live-checked (opt-in) |

Unknown app ids, DataForSEO errors, apps with no data, listing rows and failed live checks are free (start fee only).

A typical 100-keyword App Store run is $0.125 before Apify's share: $0.005 start + $0.02 lookup + 100 × $0.001.

The Apify free plan covers 1 app, 20 keyword rows and 1 competitor per run, with live check off. Any paid Apify plan unlocks the full caps.

### Data and licensing

Keyword stats, ranks, app titles, ratings and icon URLs come from DataForSEO's licensed Labs App Store and Google Play endpoints (`keywords_for_app`, `app_competitors`). App metadata (title, subtitle, description, tags) and optional live search results come from DataForSEO's licensed App Data API. We never fetch apps.apple.com or play.google.com ourselves. No personal data is collected (developer names are businesses). No AI is used. Not affiliated with Apple or Google.

### Limits

- US English store only (a DataForSEO Labs limit for these endpoints).
- Ranks can be 1 to 8 weeks old. The last-checked date is on every row.
- Volume is a DataForSEO estimate, not Apple popularity and not a live rank.
- Google Play keyword data can be noisy. Use the `noiseFlag` column; flagged rows are excluded from the listing builder.
- Up to 1,000 keyword rows, 5 competitors, and 20 live checks per run.
- Discovery rows have app ids and store URLs, not titles (DataForSEO does not return titles on that endpoint).

### FAQ

**Is this Apple's popularity score?** No. Every volume number is estimated volume (DataForSEO). We never call it Apple popularity or a live rank.

**How fresh is the data?** Each row has `lastChecked` and `ageDays`. In our checks, rank dates were typically 1 to 8 weeks old. Opportunity score is lowered as a row gets older.

**Can I get a live rank?** Yes, optionally. Set `liveCheckTopN` to how many of the top scored, non-flagged keywords you want confirmed in a live App Store or Play search. It costs $0.02 per successful keyword. If you leave it at 0, you still get the Labs last-checked date.

**What does the noise flag mean?** The keyword shares no word with the app's title, subtitle, description or tags (whichever DataForSEO app info actually returned). Those rows stay in the table and stay out of the keyword field.

**How is the iOS keyword field built?** Best-scoring gap, behind or ranked words, excluding words already in the title or subtitle, singular and plural forms deduped, comma-separated with no spaces, capped at 100 characters.

**Do you support other countries or languages?** Not on this Actor. DataForSEO's Labs keywords-for-app data is US English only.

**Do you fetch the App Store or Google Play yourselves?** No. A licensed data provider does.

Questions: hello@vncntlabs.com

# Actor input Schema

## `app` (type: `string`):

An App Store id or URL (for example 571800810 or https://apps.apple.com/app/id571800810) or a Google Play package or URL (for example com.calm.android). The store is detected automatically when Store is set to Auto.

## `store` (type: `string`):

Auto-detect is usually enough. Set this only when you want to force a store.

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

App keywords is the default. Gap mode needs at least one competitor. Discovery lists competing apps, not keywords.

## `competitors` (type: `array`):

Up to 5 competitor App Store ids, Play packages, or store URLs. Required for gap mode. Used as an optional cap in discovery mode.

## `limit` (type: `integer`):

How many keyword rows to return (app-keywords and gap modes), or how many competitor apps to return in discovery mode. Default 100, max 1,000. The prefilled 20-keyword App Store run is sized to finish well inside 5 minutes. Gap mode always requests at least 20 keywords per competitor.

## `minVolume` (type: `integer`):

Drop keywords whose estimated volume (DataForSEO) is below this number. Default 0 (no floor).

## `maxRank` (type: `integer`):

Optional. In app-keywords mode, only keep keywords where your app ranks at or above this position (1 is the best). Leave empty to include every rank DataForSEO has, up to 100.

## `competitorRankMax` (type: `integer`):

In gap mode, only pull competitor keywords where they rank at or above this position. Default 20.

## `liveCheckTopN` (type: `integer`):

Optional. After scoring, live-check the top N non-flagged keywords in the App Store or Play search (DataForSEO App Data, standard queue with a 60-second priority hedge). Adds a liveRank and last-live-checked time on those rows. Default 0 (off). Each successful check is billed as a live-rank-check event. Leave at 0 for the daily prefilled test.

## Actor input object example

```json
{
  "app": "571800810",
  "store": "app_store",
  "mode": "app_keywords",
  "limit": 20,
  "minVolume": 0,
  "competitorRankMax": 20,
  "liveCheckTopN": 0
}
```

# Actor output Schema

## `listing` (type: `string`):

No description

## `keywords` (type: `string`):

No description

## `competitors` (type: `string`):

No description

## `all` (type: `string`):

No description

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

No description

# 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 = {
    "app": "571800810",
    "store": "app_store",
    "mode": "app_keywords",
    "limit": 20,
    "liveCheckTopN": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/aso-keyword-research").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 = {
    "app": "571800810",
    "store": "app_store",
    "mode": "app_keywords",
    "limit": 20,
    "liveCheckTopN": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/aso-keyword-research").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 '{
  "app": "571800810",
  "store": "app_store",
  "mode": "app_keywords",
  "limit": 20,
  "liveCheckTopN": 0
}' |
apify call vncntlabs/aso-keyword-research --silent --output-dataset

```

## MCP server setup

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

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/aryvWpcVioJgk3dvN/builds/RaNG4KJR8qH7S4H0C/openapi.json
