# App Store and Google Play Keywords: a-z, question words (`tallyrake/appstore-autocomplete-scraper`) Actor

App Store and Google Play autocomplete keyword suggestions as CSV/JSON rows, for ASO keyword research. Columns: seed, suggestion, position, store, id. Switchable expansions: a-z, question words, prepositions, comparisons, numbers. Suggestions only: no search volume, difficulty or app rankings.

- **URL**: https://apify.com/tallyrake/appstore-autocomplete-scraper.md
- **Developed by:** [Tallyrake Data](https://apify.com/tallyrake) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## App Store & Google Play Keyword Scraper: a-z suggestions

App Store and Google Play search-box suggestions as CSV/JSON rows. Give it seed keywords; it requests the suggestions each store shows as a user types, for the seed, seed + a to z, question words, and prepositions (comparisons and numbers only if you enable those expansions), for the country and language you set, on Apple, Google Play, or both. One flat row per unique suggestion per seed per store, each with a stable `id`.

This is **not** app listings, **not** reviews, and **not** rankings. It does not return app IDs, titles, screenshots, ratings, review text, or chart positions. It is the dropdown list from each store's search box, nothing else.

Same engine, other search boxes: [Google](https://apify.com/tallyrake/google-autocomplete-scraper), [YouTube](https://apify.com/tallyrake/youtube-autocomplete-scraper), [Amazon](https://apify.com/tallyrake/amazon-autocomplete-scraper), [Bing](https://apify.com/tallyrake/bing-autocomplete-scraper), [DuckDuckGo](https://apify.com/tallyrake/duckduckgo-autocomplete-scraper), [Etsy](https://apify.com/tallyrake/etsy-autocomplete-scraper), [Pinterest](https://apify.com/tallyrake/pinterest-autocomplete-scraper), [TikTok](https://apify.com/tallyrake/tiktok-autocomplete-scraper). Same input shape, same flat rows, one run per engine.

### What you get

| Field | Example |
|---|---|
| `id` | stable per store, seed and suggestion (`sha1(store\|seed\|suggestion)`, first 16 hex) |
| `keyword` | `photo` (your seed) |
| `query` | `photo` (the exact string sent) |
| `suggestion` | `photo editor` |
| `rank` | `1` (position in that store's list for that query) |
| `store` | `apple` or `google-play` |
| `expansion` | `direct`, `alphabet`, `question`, `preposition`, `comparison`, `number`, `depth` |
| `modifier` | `b`, `how`, `for`, `vs` |
| `depth` | `1` or `2` |
| `language`, `country` | `en`, `us` |
| `fetchedAt` | ISO timestamp |

Rows are deduplicated per seed per store (case-insensitive), so a suggestion that appears under several modifiers is counted once, under the first query that produced it. The same phrase on Apple and Google Play is two rows, with different `store` and `id` values.

### Example input

```json
{
  "keywords": ["photo"],
  "stores": ["apple", "google-play"],
  "expansions": ["alphabet", "questions", "prepositions"],
  "depth": 1,
  "language": "en",
  "country": "us",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

Paste seeds one per line. The default expansions send 52 queries per seed per store (1 seed + 26 letters + 14 question words + 11 prepositions = 52). Comparisons and numbers are not in that 52; they are extra expansions. With both stores selected that is 104 requests per seed before depth 2. One seed sends many queries; the output is unique dataset rows, not queries.

Proxy defaults to Apify Proxy with no proxy group (datacenter). Apple localises with `X-Apple-Store-Front` and a `country` query param; Google Play localises with `hl` / `gl`. Pin a country on the proxy as well if you need a genuine other-market exit IP.

### Recipes

**ASO keyword list for one app idea.** Seeds: the head terms you would put in the title. Expansions: alphabet. Depth 1. Stores: both. Output: the phrases each store suggests, ranked on the query that first produced them.

**Question research.** Seeds: your topic. Expansions: questions, prepositions. Depth 1. Output: the questions and phrasings people type into App Store and Play search.

**Localized suggestions.** Same seeds, `language` and `country` set per run (`de`/`de`, `ja`/`jp`, `pt`/`br`). Rows carry both codes so runs can be merged.

**Brand and competitor monitoring.** Seeds: brand names. Expansions: comparisons, questions. Schedule daily. Diff the `suggestion` column between runs, per `store`.

### Reliability and cost

Billing terms are on the Pricing tab of the listing. Apify platform usage is a separate charge and is not the listing price. Empty queries produce no rows. Every request is paced with a jittered delay (`pacingMs`, default 200 ms). If a store answers 429 or 403, the run rotates its session and retries.

No soaked run has been measured on Apify yet, so this README does not state a success rate or a platform-usage cost.

### Cost limit

If a run reaches the "Maximum total charge per run" you set, it stops in process rather than being aborted by the platform: the run ends with status SUCCEEDED, and the run status message on the run detail says how many rows were written and how many were found but not written. Re-running the same input writes the same prefix again, so raise the cap before re-running if you want the rest.

### Bigger jobs

Need this as a one-off file instead of a run? Ask for a quote at https://tallyrake.com/datasets/. We may decline. A quote binds nothing, and a job exists only when we confirm it in writing, before any payment.

### Limits

This is each store's suggestion list for the country and language you set, at the time of the run. It carries no search volume, no difficulty, and no ranking. Apple returned 10 hints per query on the build probe; Google Play returned 5. Export CSV for Excel and Google Sheets. Export JSON for pipelines.

It is not an app-listing scraper, not a reviews scraper, and not a rankings / top-charts scraper. It does not log in, does not download IPA/APK files, and does not walk search-result pages.

### Where this sits on the shelf

Apify Store, read 2026-10-18. This actor is not published. Nothing in this build charges a custom event. One default dataset row is one result.

| Listing | Users (30d) | Total users |
|---|---|---|
| codingfrontend/app-store-keywords-discovery-tool | 1 | 2 |
| tallyrake/appstore-autocomplete-scraper (this actor) | 0 | 0 |

# Actor input Schema

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

One seed per line. Each seed is expanded (see Expansions) and every expanded query is sent to the selected store search-suggestion endpoints.

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

Which search boxes to query. apple: App Store / iTunes search hints. google-play: Play Store web search suggestions. Default is both.

## `expansions` (type: `array`):

How to fan each seed out. alphabet: seed + a..z (26 queries). questions: who/what/why/how/when/where/which/is/are/can/does/do/will/should + seed (14). prepositions: seed + for/with/without/to/near/in/on/from/like/after/before (11). comparisons: seed + vs/or/versus/and (4). numbers: seed + 1..5/10/2026 (7). The plain seed is always queried.

## `depth` (type: `integer`):

1 = expand the seeds only. 2 = also send every first-level suggestion back to the same store (capped by Max queries per keyword).

## `maxQueriesPerKeyword` (type: `integer`):

Cap on the number of suggestion requests made per seed per store, across expansions and depth. Each selected store is queried separately.

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

Interface language code. Apple: Accept-Language (and the storefront language-variation when known). Google Play: hl. Examples: en, de, es, pt, ja.

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

Two-letter country code. Apple: sent as the country query param and as X-Apple-Store-Front. Google Play: gl. Examples: us, gb, de, in, br.

## `dedupe` (type: `boolean`):

Keep the first occurrence of each suggestion per seed keyword per store (case-insensitive).

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

Apify Proxy, datacenter by default (leave proxy groups empty). The run rotates its session on HTTP 429 or 403. Residential is optional if datacenter is blocked.

## `maxConcurrency` (type: `integer`):

Parallel suggestion requests. 3 is the house default; up to 10 with Apify Proxy.

## `pacingMs` (type: `integer`):

Base jittered delay between requests per worker; 0 disables pacing.

## Actor input object example

```json
{
  "keywords": [
    "photo"
  ],
  "stores": [
    "apple",
    "google-play"
  ],
  "expansions": [
    "alphabet",
    "questions",
    "prepositions"
  ],
  "depth": 1,
  "maxQueriesPerKeyword": 300,
  "language": "en",
  "country": "us",
  "dedupe": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3,
  "pacingMs": 200
}
```

# Actor output Schema

## `suggestions` (type: `string`):

All suggestion rows (one per suggestion per seed per store).

## `csv` (type: `string`):

The same rows as CSV.

# 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": [
        "photo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tallyrake/appstore-autocomplete-scraper").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": ["photo"] }

# Run the Actor and wait for it to finish
run = client.actor("tallyrake/appstore-autocomplete-scraper").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": [
    "photo"
  ]
}' |
apify call tallyrake/appstore-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tallyrake/appstore-autocomplete-scraper"
        }
    }
}
```

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/hfWdABPbNYckGEzEa/builds/wWGu9j3FlDvrARxIy/openapi.json