# App Store Keyword Search and App Data Export (`datawharf/app-store-keyword-search`) Actor

Search the App Store by keyword and export clean app data: name, developer, price, rating, genre, and more. Structured CSV, Excel, or JSON from Apple's public iTunes Search API. No key, no login.

- **URL**: https://apify.com/datawharf/app-store-keyword-search.md
- **Developed by:** [Brad Holder](https://apify.com/datawharf) (community)
- **Categories:** Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## App Store Keyword Search

Search the Apple App Store by keyword and get clean, structured app data back. This actor runs on Apple's public iTunes Search API, so it is fast, reliable, and needs no API key, no login, and no proxies. Give it one or more keywords and it returns a tidy row for every matching app: name, developer, price, rating, genre, version, and more.

- Search the App Store by keyword
- Export app name, developer, price, rating, and genre
- Get structured App Store data as CSV, Excel, or JSON
- No API key or login required

Because it uses an official public API rather than fragile HTML scraping, there is nothing to break when a web page changes its layout. That makes it dependable for scheduled monitoring and easy to run at scale.

### What it does

You provide a list of search terms and an App Store region. For each term, the actor queries Apple's iTunes Search API and writes one dataset row per app, up to your chosen limit. You can optionally filter out apps below a minimum rating. Results export to JSON, CSV, or Excel like any Apify dataset.

### Who it is for

- App developers and product managers who want to track competitors, watch pricing, and study feature updates.
- ASO and marketing teams researching which apps rank for a keyword and how they are positioned.
- Market researchers and analysts building app-market databases by category, country, and price point.
- Data scientists gathering structured app metadata for analysis or model training.

### Use cases

1. Keyword competitive scan. Search a keyword like "habit tracker" and pull the top apps that rank for it, then compare their ratings, prices, and genres to size up a niche before you enter it.
2. Category and pricing research. Run several related keywords across a region to map how apps in a space are priced, which are free, and which charge, so you can benchmark your own pricing.
3. Scheduled rating monitoring. Save a set of competitor keywords and schedule a daily or weekly run to watch how ratings and version numbers move over time, then pipe the data to Google Sheets for a trend view.
4. Multi-region comparison. Run the same keywords across the us, ca, gb, and de regions to see how the same app space differs by market.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| searchTerms | array of strings | required | One or more keywords. Each is searched separately. |
| country | string | us | Two-letter App Store region code, for example us, ca, gb, de. |
| limit | integer | 25 | Maximum apps per keyword. Apple caps search at 200. |
| minRating | integer | 0 | Keep only apps rated at or above this value, from 0 to 5. Use 0 to keep every app. |

#### Example input

```json
{
  "searchTerms": ["photo editor", "habit tracker"],
  "country": "ca",
  "limit": 25,
  "minRating": 4
}
````

### Output

One dataset row per app. Fields include appId, appName, bundleId, developer, sellerName, price, formattedPrice, currency, rating, ratingCount, ratingCurrentVersion, ratingCountCurrentVersion, primaryGenre, genres, description, version, releaseDate, currentVersionReleaseDate, minimumOsVersion, contentRating, fileSizeBytes, languages, iconUrl, screenshotUrls, appUrl, searchTerm, and scrapedAt.

#### Example output row

```json
{
  "appId": 389801252,
  "appName": "Instagram",
  "bundleId": "com.burbn.instagram",
  "developer": "Instagram, Inc.",
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "rating": 4.69,
  "ratingCount": 28826312,
  "primaryGenre": "Photo & Video",
  "genres": ["Photo & Video", "Social Networking"],
  "version": "421.0.0",
  "minimumOsVersion": "16.0",
  "contentRating": "12+",
  "appUrl": "https://apps.apple.com/us/app/instagram/id389801252",
  "searchTerm": "photo editor",
  "scrapedAt": "2026-07-15T12:00:00.000Z"
}
```

### Pricing

This actor uses pay per event pricing. You pay a small fee for each app row it returns, plus the standard Apify start event. There is no monthly subscription and no charge for apps that are filtered out. The exact per-row price is shown on the actor's pricing tab.

### How it works

The actor calls Apple's iTunes Search API endpoint at itunes.apple.com/search with your keyword, region, and the software entity filter. It reads the JSON response, maps each result to a clean and consistent row, applies your optional rating filter, and writes the rows to the dataset. A short delay runs between keywords to stay well within Apple's public rate limits.

### Frequently asked questions

#### Do I need an Apple developer account or API key?

No. The iTunes Search API is a public endpoint. This actor needs no key, no login, and no cookies.

#### Is it legal to use this data?

The actor reads only publicly available app metadata through Apple's official public API, the same information any visitor sees on the App Store. As always, review the terms that apply to your specific use case.

#### Why are some fields empty?

Not every app fills in every field. For example, a small developer may not set a seller URL, and an app with too few ratings may not show an average rating. Missing values come back as null so your output stays consistent.

#### How many results can I get per keyword?

Apple's search API returns up to 200 results per query. Set limit up to 200. For broader coverage, run several related keywords and remove duplicates by appId.

#### Can I search a specific country's App Store?

Yes. Set country to the two-letter region code you want, such as us, ca, gb, or de. Results and pricing are region specific.

#### Can I schedule this to run automatically?

Yes. Use Apify Schedules to run your keyword set daily or weekly, then send the output to Google Sheets or your database to build a history of how ratings and versions change.

### Related tools by DataWharf

- [App Store ASO Keyword Tool](https://apify.com/datawharf/app-store-aso-keyword-tool) - track App Store keyword rankings, difficulty, and where your app ranks.
- [App Store Reviews and Sentiment](https://apify.com/datawharf/app-store-reviews-sentiment) - pull App Store reviews with a built-in sentiment tag.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more keywords to search on the Apple App Store, for example photo editor or habit tracker. Each keyword is searched separately.

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

Two-letter App Store region code, for example us, ca, gb, or de. Results and pricing vary by region.

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

Maximum number of apps to return for each keyword. Apple's search API caps results at 200 per query.

## `minRating` (type: `integer`):

Optional filter. Only keep apps with an average rating at or above this value, from 0 to 5. Leave at 0 to keep every app.

## Actor input object example

```json
{
  "searchTerms": [
    "photo editor",
    "habit tracker"
  ],
  "country": "us",
  "limit": 25,
  "minRating": 0
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("datawharf/app-store-keyword-search").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 = { "searchTerms": ["photo editor"] }

# Run the Actor and wait for it to finish
run = client.actor("datawharf/app-store-keyword-search").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "photo editor"
  ]
}' |
apify call datawharf/app-store-keyword-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datawharf/app-store-keyword-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Keyword Search and App Data Export",
        "description": "Search the App Store by keyword and export clean app data: name, developer, price, rating, genre, and more. Structured CSV, Excel, or JSON from Apple's public iTunes Search API. No key, no login.",
        "version": "0.1",
        "x-build-id": "OI2eX2emj1rRFTEbq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datawharf~app-store-keyword-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datawharf-app-store-keyword-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datawharf~app-store-keyword-search/runs": {
            "post": {
                "operationId": "runs-sync-datawharf-app-store-keyword-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datawharf~app-store-keyword-search/run-sync": {
            "post": {
                "operationId": "run-sync-datawharf-app-store-keyword-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One or more keywords to search on the Apple App Store, for example photo editor or habit tracker. Each keyword is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter App Store region code, for example us, ca, gb, or de. Results and pricing vary by region.",
                        "default": "us"
                    },
                    "limit": {
                        "title": "Max apps per term",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of apps to return for each keyword. Apple's search API caps results at 200 per query.",
                        "default": 25
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional filter. Only keep apps with an average rating at or above this value, from 0 to 5. Leave at 0 to keep every app.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
