# App Store Keywords Scraper: Suggestions as JSON | Scrapier (https://scrapier.io/scrapers/app-store/keywords/)

> App Store Keywords Scraper API: the search suggestions the App Store shows for any keyword, as JSON, for ASO keyword research. 1 credit per call. Free key.

Last updated: 2026-11-12

**GET**/api/v2/app-store-keywords-suggestion/

## App Store Keywords Scraper

The search suggestions the App Store shows as you type a keyword, returned as typed JSON for ASO keyword research: each suggestion with its keyword, type and text. 1 credit per call. No Apple login, no proxies to manage.

[Get a free API key →](https://app.scrapier.io/sign-up) [View API docs](https://scrapier.io/scrapers/app-store/keywords/api/)

Free API key · 1 credit per keyword lookup · failed calls free

Last updated 9 Nov 2026

// GET /api/v2/app-store-keywords-suggestion/?queries=light · sample from the catalog
{
  "success": true,
  "data": {
    "queries": "light",
    "result": {
      "query": "light",
      "success": true,
      "suggestions": \[
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "light"
        },
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "lightroom"
        },
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "lightning tracker"
        }
      \]
    },
    "next\_cursor": null
  }
}

Copy for your AI agent

Pricing

[1 credit / keyword lookup](https://scrapier.io/pricing/)

From $1.58 per 1,000 on Pro

Endpoint facts

Credits per call**1**

Pagination**single lookup**

App Store login**Not needed**

Format**JSON**

Auth

`X-API-Key: <your key>`

MCP tool

`run_scrape · app-store-keywords-suggestion`

One of six tools in the Scrapier MCP server, which reach all 199 endpoints.

Platform

[App Store: 4 endpoints →](https://scrapier.io/scrapers/app-store/)

Quick answer

Scrapier's App Store Keywords Scraper returns the search suggestions the App Store shows for a keyword as JSON. Each suggestion in `suggestions` has `keyword`, `type` and `item`. It is a suggestions lookup, not a rank tracker, and it costs 1 credit per successful call. Send one keyword per call. No Apple login is needed.

Every request is fetched live at call time · failed calls are free

App Store Keywords Scraper collects the search suggestions the App Store offers when someone types a keyword, one keyword per call. Each result lists the suggested terms, so you can see which phrases people are steered towards, such as lightroom or lightning tracker for light. Use \<code>max\_items\</code> to cap how many come back. Every response is structured JSON, ready to pass directly to an LLM, a spreadsheet or an ASO workflow. It is one of 4 App Store endpoints on the same API key used by 12,000+ developers. Next, feed the best terms into a search.

## What data can I extract with App Store Keywords Scraper?

Using this App Store Keywords Scraper, you can extract the following data from public App Store keyword lookups:

Searched keyword

Suggestion keyword

Suggestion type

Suggested term

Lookup success flag

Keyword echoed in the response

Next-page cursor

Suggestion list

Want the exact field names? See the [example output](#output).

Playground

## Try App Store Keywords Scraper Live

Press **Run** to see the catalog sample. Add your API key and it runs a real call to the Scrapier API from your browser. The key is sent only to proxy.scrapier.io and never stored.

App Store**App Store Keywords Suggestion**Live

Platform

Endpoint

Parameters

### \+ Run live with your API key

Response

Sample dataCatalog sample, run to see live data

## How to use App Store Keywords Scraper

Hand it to your AI assistant, or run it yourself in five steps.

### Copy to your AI assistant

Paste this into ChatGPT, Claude or Cursor and it knows how to call the scraper.

Use the Scrapier App Store Keywords Scraper to get public App Store keyword lookups. Endpoint: GET https://proxy.scrapier.io/api/v2/app-store-keywords-suggestion/?queries={queries} with header "X-API-Key: YOUR\_API\_KEY" and a 210-second timeout. Send one value per call in queries; for a list, make one call per value, at most 3 in parallel. It returns JSON under data.result: query, success, suggestions. Each successful call costs 1 credit; failed calls are free. If you support MCP, run: claude mcp add -t http scrapier https://mcp.scrapier.io/mcp --header "X-API-Key: YOUR\_API\_KEY" and call run\_scrape with endpoint "app-store-keywords-suggestion" (find it with search\_endpoints).

**App Store Keywords Scraper MCP Server**

Use this scraper from ChatGPT, Claude or Cursor. Point your assistant at Scrapier and it reads App Store keyword lookups on its own: no glue code, no scraping logic in your prompts.

[MCP setup →](https://scrapier.io/scrapers/app-store/keywords/mcp/)

### Run it yourself

1. **Get your free Scrapier API key**Sign up at [app.scrapier.io](https://app.scrapier.io/sign-up); the free tier lets you try it first.
2. **Open App Store Keywords Scraper in the catalog**It lives under [Scrapers / App Store](https://scrapier.io/scrapers/app-store/), next to the other App Store tools.
3. **Enter the keyword**Type a seed keyword such as `light` in `queries`. Use `max_items` if you want fewer suggestions than the default of 50.
4. **Send your API request**One GET with your key in the `X-API-Key` header, or one `run_scrape` call from your agent. This is how to run an App Store keyword lookup without a browser. Set a 210-second client timeout.
5. **Save your results**The suggestions come back as JSON in `data.result.suggestions`: store them as is, or flatten them to CSV. It is a lookup endpoint, so `next_cursor` is null.

### How to scale to bulk App Store keyword lookups

`queries` takes one keyword per call, so for a list you loop: one request per keyword. There is no paging, because `next_cursor` is always null. Run up to 3 requests in parallel per API key; above that the API answers 429 with a `Retry-After` header, and throttled calls cost nothing. Each call is 1 credit and failed calls are free, so 1,000 keywords cost 1,000 credits, inside the Hobby plan's 15,000.

## Features

This App Store keyword research scraper turns a seed term into the suggestions the store itself shows. It suits ASO keyword discovery, listing copy, competitor research, content planning and any workflow that needs App Store search terms without parsing HTML.

It extracts, per keyword lookup

- **Suggestions**`keyword`, `type` and `item` for every suggestion
- **Seed keyword**`query` echoes the term you searched
- **Result cap**`max_items` limits how many suggestions come back
- **Aliases**`queries` also accepts `keyword` and `query`
- **One call**A lookup endpoint: `next_cursor` is null, no paging

Proxies, retries and parsing run on Scrapier's side, so you send one request and get JSON back, at **1 credit per keyword lookup** and **0 credits for a failed call**.

## Use cases

- **ASO specialist** feeds seed terms in and collects the suggested phrases to find keywords worth adding to a listing.
- **Indie developer** checks what the store suggests for a feature name before choosing an app subtitle.
- **Content marketer** turns the suggestions for a topic into blog and landing-page ideas that match how people search the store.
- **Competitive analyst** runs a rival's brand name as a seed and reads which terms the store links to it.
- **AI engineer** gives an agent a tool that expands a keyword into App Store suggestions, so it can propose listing keywords and cite where they came from.

Running these from an agent? Use the [MCP integration](https://scrapier.io/scrapers/app-store/keywords/mcp/) and let Claude or Cursor call the scraper directly.

## Why choose this Scraper API?

**Straight from the store.**

The terms are the suggestions the App Store returns for your seed, not a modelled list from another tool.

**Simple, predictable input.**

One keyword in `queries`, an optional `max_items`, and nothing else to tune.

**One key for the App Store and the rest of the catalog.**

The same key works across Scrapier's endpoints, so suggestions can feed a search or reviews call without new code.

## Input

The scraper takes one search keyword per call in `queries`. It is required. Send parameters in the query string (GET) or as a JSON body (POST).

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `queries` | string | Yes | — | The search keyword, for example `light`. One per call. Required. Aliases: `keyword`, `query` |
| `max_items` | integer | No | `50` | How many suggestions to return, default `50` |
| `use_proxy` | boolean | No | `true` | Route through Scrapier's residential proxy pool, on by default. Leave as is |
| `raw_data` | boolean | No | `false` | Return the raw upstream payloads under `raw_responses` instead of the formatted items |

One keyword per call: to research ten keywords, make ten calls. Booleans are the strings `true` or `false`.

### Example input

POST body · input.json

{
  "queries": "light",
  "max\_items": "50",
  "use\_proxy": "true",
  "raw\_data": "false"
}

### Error codes

| Status | Meaning | Billed | Fix |
| --- | --- | --- | --- |
| 200 | Keyword lookup data returned in `data.result` | Yes | — |
| 400 | Bad or missing input | No | Check `queries`: one value per call |
| 401 | `X-API-Key` header missing | No | Add the header |
| 402 | Out of credits (body has `balance`) | No | Top up; retrying will not help |
| 403 | Invalid or revoked API key | No | Check the key in your dashboard |
| 429 | Throttled | No | Wait `Retry-After` seconds, then retry |
| 5xx | Upstream failure or timeout | No | Retry with backoff; set a 210 s client timeout |

From the [error reference](https://docs.scrapier.io/errors/). Any non-2xx response costs 0 credits.

## Output

Typed JSON with the same schema on every call. One call returns a `result` object with 3 fields, including the `suggestions` list, inside the standard `data` envelope. Field names stay the same on every call.

### Example output

200 OK · 1 credit · catalog sample

{
  "success": true,
  "data": {
    "queries": "light",
    "result": {
      "query": "light",
      "success": true,
      "suggestions": \[
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "light"
        },
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "lightroom"
        },
        {
          "keyword": "light",
          "type": "suggestion",
          "item": "lightning tracker"
        }
      \]
    },
    "next\_cursor": null
  }
}

The catalog's sample response for `queries=light`, labelled as a sample: live calls return the account's current values.

### Result

| Field | Type | Example | Description |
| --- | --- | --- | --- |
| `result.query` | string | `"light"` | The keyword that was looked up |
| `result.success` | boolean | `true` | true when the lookup worked |
| `result.suggestions` | array | `3 items` | List of suggestions, each with keyword, type and item |

### Response envelope

| Field | Type | Example | Description |
| --- | --- | --- | --- |
| `success` | boolean | `true` | true on every 200 response |
| `data.queries` | string | `"light"` | Your input, echoed back |
| `data.next_cursor` | null | `null` | Always null: this is a lookup endpoint with no paging |

## How does it work?

01

Scrapier sends each request through its residential proxy pool (`use_proxy`, on by default), so you never manage IPs or proxy accounts.

02

Retries and parsing happen on Scrapier's side. You send one HTTP request and get typed JSON back.

03

Only publicly visible data is returned: the suggestions any visitor sees when typing in the App Store search box. No Apple account or cookie is used.

04

The schema is stable. When the store changes, Scrapier updates the scraper; the field names in the result stay the same.

## How do you integrate App Store Keywords Scraper into your stack?

It works with what you already use: any HTTP client, AI agents over MCP, and no-code automation tools. Code samples for cURL, Python and Node.js are on the [API tab](https://scrapier.io/scrapers/app-store/keywords/api/).

### MCP integration for AI agents

claude mcp add -t http scrapier …

This registers the Scrapier MCP server, whose tools reach every Scrapier scraper, including `app-store-keywords-suggestion`: the agent finds it with `search_endpoints` and calls it with `run_scrape`. Works with Claude Code, Cursor and Windsurf. MCP calls are billed like REST: 1 credit per successful call. [Full MCP setup →](https://scrapier.io/scrapers/app-store/keywords/mcp/)

### No-code tools (n8n, Make, LangChain)

**n8n**

Use the HTTP Request node with your Scrapier API key in an `X-API-Key` header and point it at `/api/v2/app-store-keywords-suggestion/` with a `queries` query parameter. Map the suggestions list into the next node.

**Make**

Add an HTTP "Make a request" module with the same header and URL, and parse the response as JSON. Map each suggestion's `item` straight into Sheets, Airtable or your CRM.

**LangChain**

Wrap the endpoint in a `requests`\-based tool, or load the Scrapier MCP server through LangChain's MCP adapters so the agent finds `app-store-keywords-suggestion` with `search_endpoints` itself.

## Pricing and Rate Limits

One App Store keyword lookup costs 1 credit, so 1,000 keyword lookups cost 1,000 credits: $1.58 on the Pro plan. Failed and empty calls are not billed. Run up to 3 requests in parallel per key; above that the API answers 429 with a `Retry-After` header.

| Plan | Monthly price | Credits | Keyword lookups included | Per 1,000 keyword lookups |
| --- | --- | --- | --- | --- |
| Hobby | $29 | 15,000 | 15,000 | $1.93 |
| Pro | $79 | 50,000 | 50,000 | $1.58 |
| Scale | $299 | 250,000 | 250,000 | $1.20 |
| Enterprise | [Custom volume and terms](https://scrapier.io/enterprise/#contact) |

Prices from the live billing page. [See all plans and limits](https://scrapier.io/pricing/).

## Call cost and timing

**1**credit per successful call

**0**credits for a failed call

**3**parallel requests per key

**210s**recommended client timeout

### How we measure this

Credit cost, pagination and the sample come from the live catalog (`GET /api/v2/endpoints`, /app-store-keywords-suggestion/, checked 9 Nov 2026). Concurrency and timeout guidance come from the [rate limits page](https://docs.scrapier.io/rate-limits/) of the docs. Scrapier does not publish latency or success-rate figures for this endpoint, so none are shown here.

## App Store Keywords Scraper vs the Official App Store API

| Feature | Scrapier keyword scraper | DIY App Store scraping |
| --- | --- | --- |
| Access needed | One Scrapier API key | Your own proxies, parser and servers |
| Which data | The search suggestions the App Store shows for a keyword | Whatever your parser extracts |
| Fields returned | 3 fields: query, success and the suggestions list | Whatever you build and maintain |
| Setup | Sign up, copy a key, send a request | Find the suggestion source, handle blocks and retries |
| Cost | 1 credit per lookup, from $1.20 per 1,000 calls | Proxy, server and engineering time |

If you need search volume, difficulty or rank tracking, use a dedicated ASO tool; this endpoint returns suggestions only. Scrapier suits teams that want one key and one JSON shape across many platforms.

## Is it legal to scrape App Store data?

Scraping publicly available web pages is generally lawful in many countries, but the answer depends on what you collect, where you are and how you use it. In the US, hiQ Labs v. LinkedIn is the case most often cited on public-data scraping. Scrapier returns only data any visitor can see without logging in, and search suggestions hold no personal data. Under GDPR and similar laws, you must still follow local data-protection rules for anything you store, and Apple's terms apply. Consult legal counsel if your use case is unclear. This is not legal advice; see our [Terms of Use](https://scrapier.io/terms/).

## Frequently asked questions

### What does App Store Keywords Scraper return?

It returns the search suggestions the App Store shows for a keyword. Each suggestion has keyword, type and item, inside a result object with query, success and suggestions: 3 fields. It does not return search volume or rank. Each call costs 1 credit.

### Is there an App Store keyword API?

Scrapier's App Store keyword API is a REST endpoint at /api/v2/app-store-keywords-suggestion/: send a keyword and your key in the X-API-Key header, and get suggestions as JSON. It costs 1 credit per call and failed calls are free.

### Can I use it for ASO keyword research?

Yes, for discovery. Seed it with a term and read which phrases the App Store suggests, then test them in your listing. It returns suggestions only, so pair it with another source if you need volume or difficulty scores.

### Does it track keyword rankings?

No. This endpoint returns search suggestions, not the position of an app for a keyword. To see which apps appear for a term, use the Apple App Store Scraper search mode, process=se, and read the order of results.

### How many suggestions do I get?

Up to max\_items, which defaults to 50. The number actually returned depends on what the App Store offers for the keyword. Lower max\_items if you want a shorter list. The call costs 1 credit either way.

### Can I look up several keywords in one call?

No. queries takes one keyword per call. For a list, make one call per keyword, up to 3 in parallel per API key. Throttled calls return 429 and cost nothing.

### Is there paging?

No. This is a lookup endpoint and next\_cursor is always null, so one call returns the whole list. You do not need to loop with a cursor.

### Does App Store Keywords Scraper require an Apple account or login?

No. App Store Keywords Scraper uses no Apple account or cookies: you send your Scrapier API key in the X-API-Key header and your keyword, and get JSON back. Only publicly visible data is returned.

### How fast does App Store Keywords Scraper run?

Scrapier does not publish a latency figure for this endpoint. Each call reads the store live, so timing varies. Set a client timeout of 210 seconds, as the docs recommend for every endpoint.

### What happens if the keyword is wrong or nothing comes back?

If a call fails, the API returns a non-2xx status and costs 0 credits. In code, check the status, then skip that keyword or retry it later. Throttled calls (429 with a Retry-After header) are free as well.

### Does App Store Keywords Scraper work with Claude, ChatGPT and other AI agent tools?

Yes. Connect the Scrapier MCP server with claude mcp add -t http scrapier https://mcp.scrapier.io/mcp and your API key in an X-API-Key header; it works in Claude Code, Cursor and Windsurf. The agent finds app-store-keywords-suggestion with search\_endpoints and calls it with run\_scrape.

### How much does it cost to run App Store Keywords Scraper 1,000 times?

1,000 credits, because each call is 1 credit. That is about $1.93 on Hobby, $1.58 on Pro and $1.20 on Scale, at the plans' price per credit. Failed calls are free.

### How do I use App Store Keywords Scraper with Python?

For an App Store keyword scraper in Python, send a GET request with the requests library to https://proxy.scrapier.io/api/v2/app-store-keywords-suggestion/ with params={"queries": "light"}, your key in the X-API-Key header and timeout=210. Read r.json()\["data"\]\["result"\]\["suggestions"\]: it is already JSON.

## Related scrapers

| Scraper | What it extracts |
| --- | --- |
| [Apple App Store Scraper](https://scrapier.io/scrapers/app-store/app-store/) | One endpoint, six modes set by process: app lookup, search, developer apps, collections, reviews and performance. |
| [Apple App Store Review Scraper](https://scrapier.io/scrapers/app-store/reviews/) | Reviews for one app, a page at a time: author, rating, title, text, date, edited flag and developer response. |
| App Scraper | One app by App Store URL or numeric ID: title, subtitle, rating and count, price, category, version and release date. |

All 4 App Store endpoints are on the [App Store scraper hub](https://scrapier.io/scrapers/app-store/).

## Your feedback

Found a bug or missing a field? Let us know. Write to support@scrapier.io and the team replies to every report.

[Report an issue](https://scrapier.io/contact/)[Email support](mailto:support@scrapier.io)

Get started

## Start Scraping App Store Keyword Lookups

Public App Store keyword lookups as JSON, 1 credit each, from REST or MCP.

[Get a free API key →](https://app.scrapier.io/sign-up)[View pricing](https://scrapier.io/pricing/)

---
Canonical page: https://scrapier.io/scrapers/app-store/keywords/
Site index for AI agents: https://scrapier.io/llms.txt
