# App Store Keyword Popularity Scores & ASO API (`asomaniac/app-store-keyword-tool`) Actor

Get Apple App Store keyword popularity scores (5-100), difficulty ratings, and ASO recommendations. Same data as AppTweak & SensorTower, pay per use. Supports 57 storefronts worldwide.

- **URL**: https://apify.com/asomaniac/app-store-keyword-tool.md
- **Developed by:** [AsoManiac](https://apify.com/asomaniac) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 94 total users, 26 monthly users, 86.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 keyword analyses

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Popularity Scores & ASO API

### 🔍 Real-time keyword popularity data from Apple Search Ads

Get **real Apple App Store keyword popularity scores** (5–100) — the same data available inside the Apple Search Ads dashboard — through a simple API. No Apple account required.

For every keyword you submit, you get:

- **Popularity score** (5–100) — Apple's official keyword search volume indicator
- **Difficulty score** (0–100) — computed competition metric calibrated against professional ASO tools (r=0.87, MAE=6.5)
- **Top ranking apps** — the apps currently dominating each keyword
- **Related searches** — autocomplete suggestions from Apple's search engine
- **Keyword recommendations** — discover 30–80 new keyword ideas from a single seed term, each with its own popularity score

All data is queried **live from Apple's servers** — not estimated, not scraped from third-party databases.

### 💡 Why use this tool?

Apple App Store keyword popularity data is locked behind expensive platforms:

| Platform | Monthly Cost | API Access |
|----------|-------------|------------|
| SensorTower | $2,000+/mo | Enterprise only |
| AppTweak | $79–549/mo | Extra $166+/mo |
| MobileAction | $69–239/mo | Enterprise only |
| App Radar | €69–299/mo | Enterprise only |

This tool provides the **same underlying Apple Search Ads keyword data** at a fraction of the cost — **$0.02 per keyword** with no subscription and no commitment.

#### Who is this for?

- **Indie developers** optimizing their App Store listing with real keyword data
- **ASO consultants and freelancers** who need keyword popularity scores without enterprise contracts
- **Mobile marketing agencies** running keyword research at scale via API
- **Data teams** building ASO pipelines, dashboards, and automated reports
- **Researchers** studying App Store search trends across 57 storefronts

If you've been looking for an **alternative to AppTweak** or an **alternative to SensorTower** that provides real Apple keyword data without a subscription, this is it.

### ⚡ Features

- **Apple keyword popularity scores** — Direct from Apple Search Ads internal API, scores from 5 (low) to 100 (high)
- **Keyword difficulty ratings** — Computed 0–100 score based on competition strength, demand signals, and market quality
- **Top ranking apps** — See which apps dominate each keyword, with ratings, review counts, and pricing
- **Related searches** — Apple autocomplete suggestions to expand your keyword list
- **Keyword recommendations** — Enter one seed keyword, get 30–80 suggestions with popularity scores
- **57 storefronts** — Full international coverage from US, UK, and Japan to Nigeria, Vietnam, and Lithuania
- **Field filtering** — Request only the data you need (popularity, difficulty, topApps, relatedSearches) for faster results
- **Smart caching** — Results cached for 24 hours across runs, so repeat lookups are instant and free
- **Spending control** — Set a maximum budget per run; the tool stops gracefully when your limit is reached

### How to use

#### Quick start

1. **Try for free** — Click "Try for free" above. Apify's free plan gives you $5/month in credits, enough for ~250 keyword analyses at no cost.

2. **Choose your action** — Pick **Keyword Analysis** to analyze specific keywords, or **Keyword Recommendations** to discover new keyword ideas from a seed term.

3. **Enter your keywords** — For analysis, type up to 100 keywords. For recommendations, enter a single seed keyword. Select your target storefront (country).

4. **Run and download** — Click "Start", then export your results as JSON, CSV, or Excel. Or call the [Apify API](https://docs.apify.com/api/v2) to integrate into your workflow.

#### API usage

Call this tool programmatically via the Apify REST API or any of the [official Apify client libraries](https://docs.apify.com/api/v2) (Python, JavaScript, etc.). See the **Input parameters** section below for full examples per action.

### Input parameters

#### Keyword Analysis

Analyze specific keywords for popularity, difficulty, competition, and related searches.

| Parameter | Type | Required | Description | Example |
|-----------|------|----------|-------------|---------|
| `action` | string | Yes | Must be `"keyword-analysis"` | `"keyword-analysis"` |
| `keywords` | string[] | Yes | Keywords to analyze, 1–100 per run | `["fitness app", "workout tracker"]` |
| `storefront` | string | No | App Store country code (uppercase). Defaults to `US` | `"GB"` |
| `fields` | string[] | No | Which data to include. Omit for all fields. Options: `popularity`, `difficulty`, `topApps`, `relatedSearches` | `["popularity", "difficulty"]` |

> **Note:** Do not pass `seedKeyword` or `limit` with keyword-analysis — the actor will reject them with a clear error message.

```bash
curl -X POST "https://api.apify.com/v2/acts/asomaniac~app-store-keyword-tool/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "keyword-analysis",
    "keywords": ["photo editor", "video editor"],
    "storefront": "JP"
  }'
````

#### Keyword Recommendations

Discover new keyword ideas from a single seed keyword.

| Parameter | Type | Required | Description | Example |
|-----------|------|----------|-------------|---------|
| `action` | string | Yes | Must be `"keyword-recommendations"` | `"keyword-recommendations"` |
| `seedKeyword` | string | Yes | Seed keyword to generate recommendations from | `"fitness"` |
| `storefront` | string | No | App Store country code (uppercase). Defaults to `US` | `"DE"` |
| `limit` | integer | No | Max recommendations to return (1–80, default 50) | `10` |

> **Note:** Do not pass `keywords` or `fields` with keyword-recommendations — the actor will reject them with a clear error message.

```bash
curl -X POST "https://api.apify.com/v2/acts/asomaniac~app-store-keyword-tool/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "keyword-recommendations",
    "seedKeyword": "meditation",
    "storefront": "DE",
    "limit": 10
  }'
```

### Output format

#### Keyword Analysis

Each keyword produces one result object per storefront:

```json
{
  "keyword": "fitness app",
  "storefront": "US",
  "popularity": 62,
  "difficulty": 78,
  "confidence": "high",
  "totalApps": 1450,
  "topApps": [
    {
      "name": "Fitbod Gym & Home Workout",
      "appId": 1041571171,
      "developer": "Fitbod Inc.",
      "rating": 4.8,
      "ratingCount": 56200,
      "price": 0,
      "genre": "Health & Fitness"
    },
    {
      "name": "Nike Training Club: Fitness",
      "appId": 301521403,
      "developer": "Nike, Inc",
      "rating": 4.7,
      "ratingCount": 412000,
      "price": 0,
      "genre": "Health & Fitness"
    }
  ],
  "relatedSearches": [
    "fitness app free",
    "fitness tracker",
    "workout app",
    "gym workout plan"
  ]
}
```

#### Keyword Recommendations

Each recommendation includes the storefront and its source (Apple's recommendation engine or autocomplete):

```json
{
  "keyword": "home workout plan",
  "storefront": "US",
  "popularity": 51,
  "source": "recommendation"
}
```

A single seed keyword typically returns 30–80 recommendations, each with a real Apple popularity score. The `storefront` field always matches the storefront you requested (or `"US"` if omitted).

### 💰 How much does it cost?

Simple, flat pricing — no tiers, no hidden fees:

| Event | Price | What you get |
|-------|-------|-------------|
| **Keyword Analysis** | **$0.02** per keyword | Popularity + difficulty + top apps + related searches (all fields included) |
| **Keyword Recommendations** | **$0.10** per seed keyword | 30–80 keyword suggestions, each with a popularity score |

#### Cost examples

| What you're doing | Keywords | Cost |
|-------------------|----------|------|
| Quick research for one app | 100 keywords | **$2.00** |
| Weekly ASO report | 500 keywords | **$10.00** |
| Full keyword audit | 1,000 keywords | **$20.00** |
| Agency batch analysis | 5,000 keywords | **$100.00** |
| Discover new keywords | 10 seed keywords | **$1.00** |

#### 🎁 Free tier

Apify's free plan includes **$5/month in platform credits**. At $0.02 per keyword, that's approximately **250 free keyword analyses per month** — enough to evaluate the tool and run basic ASO research at zero cost.

#### Spending control

Set a maximum budget per run using Apify's built-in spending limits. The tool stops gracefully when your cap is reached — you'll never be charged more than you expect.

### 📊 How is this different from AppTweak / SensorTower?

| Feature | This Tool | AppTweak | SensorTower | Astro |
|---------|-----------|----------|-------------|-------|
| Apple popularity scores (5–100) | Yes (direct from Apple) | Yes (direct from Apple) | Estimated | Yes (direct from Apple) |
| Keyword difficulty | Yes (0–100) | Yes | Yes | Yes |
| Keyword recommendations | Yes (direct from Apple) | Yes | Yes | No |
| Top ranking apps | Yes | Yes | Yes | Yes |
| Related searches | Yes | Yes | Yes | No |
| Search volume estimates | Planned | Yes (since 2016) | Yes | No |
| API access | Yes (Apify REST API) | Extra $166+/mo | Enterprise only | None |
| Storefronts | 57 | 60+ | 60+ | 60+ |
| **Pricing** | **$0.02/keyword** | **$79–549/mo** | **$2,000+/mo** | **$9/mo** |
| Commitment | None (pay per use) | Monthly subscription | Annual contract | Annual |
| Data source | Apple Search Ads API | Apple Search Ads API | Proprietary estimates | Apple Search Ads API |

This is a focused **iOS keyword popularity score API** and **ASO keyword research tool**. Enterprise platforms offer more features (historical trends, competitor tracking, account management). This tool does one thing well: get you real Apple keyword data at the lowest possible cost.

### Data sources

All data comes directly from Apple:

1. **Apple Search Ads internal API** — The same endpoint that powers the Apple Search Ads dashboard. Returns official keyword popularity scores (5–100) and keyword recommendations. This is real **Apple Search Ads keyword data**, not estimates.

2. **iTunes Search API** — Public API for app metadata, rankings, and search results. Used for top ranking apps and total result counts.

3. **iTunes Search Hints API** — Apple's autocomplete suggestions. Used for related searches and to supplement keyword recommendations.

Data is queried **in real time** on every run. Cached results (24-hour TTL) are served when available to save time and cost, but the underlying data is always fresh from Apple.

### Supported storefronts

This tool supports all **57 App Store storefronts** where Apple Search Ads operates. Pass the two-letter country code (uppercase) as the `storefront` parameter. Defaults to `US` if omitted.

#### Americas (8 storefronts)

| Code | Country |
|------|---------|
| `US` | United States |
| `CA` | Canada |
| `BR` | Brazil |
| `MX` | Mexico |
| `CO` | Colombia |
| `CL` | Chile |
| `AR` | Argentina |
| `PE` | Peru |

#### Europe (27 storefronts)

| Code | Country |
|------|---------|
| `GB` | United Kingdom |
| `DE` | Germany |
| `FR` | France |
| `ES` | Spain |
| `IT` | Italy |
| `NL` | Netherlands |
| `SE` | Sweden |
| `NO` | Norway |
| `DK` | Denmark |
| `FI` | Finland |
| `PT` | Portugal |
| `CH` | Switzerland |
| `AT` | Austria |
| `BE` | Belgium |
| `IE` | Ireland |
| `PL` | Poland |
| `CZ` | Czech Republic |
| `HU` | Hungary |
| `RO` | Romania |
| `GR` | Greece |
| `TR` | Turkey |
| `UA` | Ukraine |
| `RU` | Russia |
| `SK` | Slovakia |
| `HR` | Croatia |
| `BG` | Bulgaria |
| `LT` | Lithuania |

#### Asia-Pacific (15 storefronts)

| Code | Country |
|------|---------|
| `JP` | Japan |
| `KR` | South Korea |
| `CN` | China |
| `IN` | India |
| `AU` | Australia |
| `NZ` | New Zealand |
| `SG` | Singapore |
| `HK` | Hong Kong |
| `TW` | Taiwan |
| `TH` | Thailand |
| `ID` | Indonesia |
| `PH` | Philippines |
| `MY` | Malaysia |
| `VN` | Vietnam |
| `PK` | Pakistan |

#### Middle East & Africa (7 storefronts)

| Code | Country |
|------|---------|
| `IL` | Israel |
| `SA` | Saudi Arabia |
| `AE` | United Arab Emirates |
| `ZA` | South Africa |
| `EG` | Egypt |
| `NG` | Nigeria |
| `KE` | Kenya |

### Tips and limitations

- **Popularity score range:** Apple returns scores from 5 (lowest reported) to 100 (highest). Keywords with near-zero search volume return no score — this means the keyword has effectively no search traffic.
- **100 keywords per run:** The Apple API accepts up to 100 terms per request. For larger batches, run the tool multiple times or use the API to automate sequential runs.
- **Caching:** Results are cached for 24 hours across runs. Repeat lookups within the cache window are instant and free (no charge). Cache misses query Apple live.
- **Difficulty methodology:** The difficulty score (0–100) is a computed metric based on competition strength (rating counts of top apps), demand signals, and market quality factors. It has been calibrated against professional ASO tools with a correlation of r=0.87 and mean absolute error of 6.5 points.
- **Rate limiting:** The tool manages Apple's rate limits automatically. Large keyword batches are processed with built-in throttling to avoid disruptions.
- **Uppercase storefronts:** Country codes must be uppercase (e.g., `US`, not `us`). The input form handles this automatically, but API users should ensure correct casing.

### FAQ

**Is this the same data as the Apple Search Ads dashboard?**
Yes. The popularity scores come from the same internal Apple Search Ads API endpoint. The numbers you see here are identical to what you'd see in Apple's dashboard.

**Do I need an Apple Search Ads account?**
No. This tool handles authentication internally. You just provide keywords and get results.

**How fresh is the data?**
Real-time. Each run queries Apple's servers directly. Results are cached for 24 hours for performance, but the underlying data source is live.

**Can I set a spending limit?**
Yes. Use Apify's built-in spending limits to cap your budget per run. The tool stops gracefully when the limit is reached and returns all results collected so far.

**Can I access this via API?**
Yes. Use the [Apify REST API](https://docs.apify.com/api/v2) or official client libraries (JavaScript, Python) to integrate keyword data into your ASO pipeline, CI/CD, or analytics dashboard. This is a full **keyword popularity score API** and **App Store Optimization API**.

**How accurate is the difficulty score?**
The difficulty score is calibrated against Astro (a professional macOS ASO tool) across 232 keywords. Correlation: r=0.87. Mean absolute error: 6.5 points on a 0–100 scale. Confidence levels (high/medium/low) are provided with each score.

**What happens if Apple changes their API?**
The tool is actively maintained. If Apple modifies their internal endpoints, updates will be pushed promptly. Session management runs on dedicated infrastructure with monitoring and alerts.

# Actor input Schema

## `action` (type: `string`):

Which operation to perform.

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

Keywords to analyze (1-100). Required for keyword-analysis action.

## `storefront` (type: `string`):

App Store country code (e.g. US, GB, DE, JP). Case-insensitive — 'us' and 'US' both work. Defaults to US.

## `fields` (type: `array`):

Which fields to include: popularity, difficulty, topApps, relatedSearches. Fewer fields = faster and cheaper. Omit for all fields.

## `seedKeyword` (type: `string`):

Seed keyword for recommendations. Optional — omit for app-specific suggestions.

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

Maximum number of recommendations to return.

## Actor input object example

```json
{
  "action": "keyword-analysis",
  "keywords": [
    "fitness app",
    "workout tracker",
    "health"
  ],
  "storefront": "US",
  "fields": [
    "popularity",
    "difficulty",
    "topApps",
    "relatedSearches"
  ],
  "limit": 50
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

Keyword popularity, difficulty, and recommendation data

# 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": [
        "fitness app",
        "workout tracker",
        "health"
    ],
    "storefront": "US",
    "fields": [
        "popularity",
        "difficulty",
        "topApps",
        "relatedSearches"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("asomaniac/app-store-keyword-tool").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": [
        "fitness app",
        "workout tracker",
        "health",
    ],
    "storefront": "US",
    "fields": [
        "popularity",
        "difficulty",
        "topApps",
        "relatedSearches",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("asomaniac/app-store-keyword-tool").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 '{
  "keywords": [
    "fitness app",
    "workout tracker",
    "health"
  ],
  "storefront": "US",
  "fields": [
    "popularity",
    "difficulty",
    "topApps",
    "relatedSearches"
  ]
}' |
apify call asomaniac/app-store-keyword-tool --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Keyword Popularity Scores & ASO API",
        "description": "Get Apple App Store keyword popularity scores (5-100), difficulty ratings, and ASO recommendations. Same data as AppTweak & SensorTower, pay per use. Supports 57 storefronts worldwide.",
        "version": "0.1",
        "x-build-id": "sGnxSq0YChPQEep1O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/asomaniac~app-store-keyword-tool/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-asomaniac-app-store-keyword-tool",
                "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/asomaniac~app-store-keyword-tool/runs": {
            "post": {
                "operationId": "runs-sync-asomaniac-app-store-keyword-tool",
                "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/asomaniac~app-store-keyword-tool/run-sync": {
            "post": {
                "operationId": "run-sync-asomaniac-app-store-keyword-tool",
                "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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "keyword-analysis",
                            "keyword-recommendations"
                        ],
                        "type": "string",
                        "description": "Which operation to perform.",
                        "default": "keyword-analysis"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Keywords to analyze (1-100). Required for keyword-analysis action.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "storefront": {
                        "title": "Storefront (Country)",
                        "type": "string",
                        "description": "App Store country code (e.g. US, GB, DE, JP). Case-insensitive — 'us' and 'US' both work. Defaults to US.",
                        "default": "US"
                    },
                    "fields": {
                        "title": "Output Fields",
                        "type": "array",
                        "description": "Which fields to include: popularity, difficulty, topApps, relatedSearches. Fewer fields = faster and cheaper. Omit for all fields.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "seedKeyword": {
                        "title": "Seed Keyword",
                        "type": "string",
                        "description": "Seed keyword for recommendations. Optional — omit for app-specific suggestions."
                    },
                    "limit": {
                        "title": "Max Recommendations",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of recommendations to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```