# Google Autocomplete Bulk Scraper (`devilscrapes/google-autocomplete-bulk`) Actor

Bulk-fetch Google Autocomplete suggestions for any list of seed keywords across the country and language matrix you choose. We rotate browser fingerprints, route via Apify Proxy, retry with backoff, and return one clean typed row per (seed, country, lang, suggestion).

- **URL**: https://apify.com/devilscrapes/google-autocomplete-bulk.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

<img src=".actor/icon.svg" width="160" alt="Google Autocomplete Bulk Scraper" />

## Google Autocomplete Bulk Scraper

_We do the dirty work so your dataset stays clean._ 😈

**$1.05 / 1,000 suggestions** — Export real Google autocomplete suggestions for many seeds across many languages and countries in a single run. Optional A–Z alphabet expansion turns every seed into 26 long-tail variants. No Google account. No SerpApi key. No browser automation.

Google's autocomplete dropdown is the canonical signal of what people are actually typing into the search box. Keyword-research SaaS like KeywordTool.io, AnswerThePublic, Ubersuggest, and SE Ranking all wrap the same public Suggest endpoint, mark it up 10–100×, and resell it. This Actor talks to the endpoint directly via the public Suggest API, fans out across seeds × languages × countries, optionally expands each seed alphabetically, and emits one denormalised dataset row per (seed × suggestion × locale) tuple — ready for SEO, PPC, content-gap, or product-research workflows.

### 🎯 What this scrapes
For every (seed × language × country) combination you submit, this Actor queries the public Google Suggest endpoint (`suggestqueries.google.com/complete/search`) and emits one row per returned suggestion. The default `client=chrome` mode returns up to 15 suggestions per call plus relevance scores and subtype tags; the lean `client=firefox` mode returns up to 10 suggestions without relevance scores. Each row carries the seed, the suggestion, its 0-indexed position, the locale used, and an `is_expansion` flag so alphabet-expanded long-tail suggestions are easy to filter or aggregate.

| Field | Type | Description |
|---|---|---|
| `seed` | string | The query string the suggestion was generated for |
| `suggestion` | string | One Google autocomplete suggestion |
| `position` | integer | 0-indexed position in the suggestion list |
| `relevance` | integer \| null | `google:suggestrelevance` score (chrome client only) |
| `subtype` | string | First `google:suggesttype` tag (`QUERY`, `NAV`, …) or `UNKNOWN` |
| `language` | string | `hl` parameter used (ISO-639-1) |
| `country` | string | `gl` parameter used (ISO-3166-1 alpha-2) |
| `client` | string | `chrome` or `firefox` |
| `is_expansion` | boolean | True if the seed was produced by alphabet expansion |
| `parent_seed` | string \| null | Original user seed when `is_expansion` is true |
| `scraped_at` | string | ISO 8601 UTC datetime |

### 🔥 Features
- **Bulk seeds** — submit up to 500 seed queries in a single run; the Actor fans out across every language × country combination you specify.
- **Multi-locale** — query the same seed across many languages (`hl`) and many countries (`gl`) in one run. The Suggest endpoint serves locale-specific results: "bestes auto" in `de`-`de` returns German automotive suggestions; "best laptop" in `en`-`us` returns US tech suggestions.
- **A–Z alphabet expansion** — toggle `enableAlphabetExpansion` to also query `<seed> a`, `<seed> b`, …, `<seed> z` for every seed. This is the canonical long-tail discovery technique: one seed × 26 letters reveals every common Google query that starts with your seed.
- **Two client variants** — `chrome` (default) returns up to 15 suggestions with relevance scores and subtype tags; `firefox` returns up to 10 suggestions in a leaner payload. Pick per run.
- **No authentication** — uses the same public Suggest endpoint browsers hit. No SerpApi key, no Google account, no OAuth.
- **Denormalised output** — every row carries the seed, locale, and provenance fields so a flat CSV is self-contained for SQL / BI / spreadsheet workflows without joins.
- **`curl-cffi` chrome131 impersonation** — replays a real Chrome TLS+H2 fingerprint so the request looks indistinguishable from a Chrome browser on a real desktop.
- **Conservative concurrency** — 2 in-flight requests per run, well below Google's documented 100/sec naive limit; honours `Retry-After` headers if rate-limited.
- **Pydantic v2 input validation** — locale codes are normalised to lowercase, length-validated, and rejected up-front if invalid before any network call.

### 💡 Use cases
- **Long-tail SEO keyword discovery** — enable alphabet expansion to enumerate every common Google query that starts with your seed; pipe into a search-volume tool to prioritise content briefs.
- **PPC negative-keyword mining** — pull alphabet-expanded suggestions across the seed for your category, then filter for adjacent products / intents you want to exclude from broad-match campaigns.
- **Content gap analysis** — query your brand + competitor names across `en`-`us`, `en`-`gb`, `en`-`au` to find geo-specific concerns and product comparisons real users are searching for.
- **Multi-market localisation research** — query the same product seed across 5–10 locales to see how local users phrase the same intent in their language; informs product copy, landing pages, and marketplace listings.
- **Trend monitoring** — schedule a recurring run on a fixed seed list and diff the suggestion list day-over-day to detect emerging interest spikes before they hit the SERP.
- **AI training-data curation** — bulk-export real human search phrasings for fine-tuning intent classifiers or query-understanding models; the suggestions are post-processed real queries, free from PII.

### ⚙️ How to use it
1. Open the Actor input form.
2. Enter your **Seed queries** — one per line (e.g. `best laptop`, `best espresso machine`, `learn python`).
3. Optionally set **Language codes** and **Country codes**. Both default to `["en"]` / `["us"]`. Use 2-letter lowercase codes (ISO-639-1 for languages, ISO-3166-1 alpha-2 for countries). For multi-locale runs, add several to each list.
4. Pick a **Suggest client**. `chrome` (default) is recommended — it returns up to 15 suggestions with relevance scores. `firefox` is leaner (up to 10 suggestions, no scores).
5. Set **Max suggestions per seed** if you want fewer than the API maximum (default 10, max 15).
6. Toggle **Enable A–Z alphabet expansion** if you want long-tail discovery — each seed will generate 26 extra queries (`<seed> a` through `<seed> z`).
7. Leave **Use Apify Proxy** off unless you are running very large jobs (>2,000 tuples) and hitting rate limits.
8. Click **Start**. Results stream into the default dataset and can be exported as JSON, CSV, Excel, or XML.

#### Single-seed example

```json
{
  "seeds": ["best laptop"],
  "languages": ["en"],
  "countries": ["us"],
  "client": "chrome",
  "maxSuggestionsPerSeed": 10,
  "enableAlphabetExpansion": false,
  "useProxy": false
}
````

#### Multi-locale + alphabet expansion example

```json
{
  "seeds": ["best laptop", "best espresso machine"],
  "languages": ["en", "de"],
  "countries": ["us", "de"],
  "client": "chrome",
  "maxSuggestionsPerSeed": 15,
  "enableAlphabetExpansion": true,
  "useProxy": false
}
```

This produces `2 seeds × 2 languages × 2 countries × (1 + 26) variants × 15 rows = up to 3,240 rows`.

### 📥 Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `seeds` | array<string> | yes | — | 1–500 seed queries |
| `languages` | array<string> | no | `["en"]` | ISO-639-1 lowercase language codes |
| `countries` | array<string> | no | `["us"]` | ISO-3166-1 alpha-2 lowercase country codes |
| `client` | string (enum) | no | `chrome` | `chrome` (up to 15 suggestions + scores) or `firefox` (up to 10) |
| `maxSuggestionsPerSeed` | integer | no | `10` | 1–15 |
| `enableAlphabetExpansion` | boolean | no | `false` | If true, also query `<seed> a` through `<seed> z` |
| `useProxy` | boolean | no | `false` | Route through Apify Proxy (BUYPROXIES94952) |

### 📤 Output

One row per suggestion. All seed / locale / provenance fields denormalised onto every row so a flat CSV is self-contained.

```json
{
  "seed": "best laptop",
  "suggestion": "best laptop 2026",
  "position": 1,
  "relevance": 900,
  "subtype": "QUERY",
  "language": "en",
  "country": "us",
  "client": "chrome",
  "is_expansion": false,
  "parent_seed": null,
  "scraped_at": "2026-05-16T12:00:00.000Z"
}
```

When alphabet expansion is enabled, expanded rows carry `is_expansion=true` and `parent_seed` set to the original seed:

```json
{
  "seed": "best laptop a",
  "suggestion": "best laptop accessories",
  "position": 0,
  "relevance": 1250,
  "subtype": "QUERY",
  "language": "en",
  "country": "us",
  "client": "chrome",
  "is_expansion": true,
  "parent_seed": "best laptop",
  "scraped_at": "2026-05-16T12:00:00.000Z"
}
```

#### Export formats

- **JSON** — full fidelity, all fields, newline-delimited
- **CSV** — flat, one row per suggestion, all columns
- **Excel** — `.xlsx` via the Apify dataset converter
- **XML** — structured per-item

All formats are available via the Apify API: `GET /datasets/{id}/items?format=csv&clean=true`.

### 💰 Pricing

Pay-Per-Event (PPE) — you pay only for what you use:

| Event | Price (USD) | When |
|---|---|---|
| `actor-start` | $0.05 | Once per run, at boot |
| `result-row` | $0.001 | Per suggestion row written to the dataset |

#### Example costs

| Run | Suggestions | Cost |
|---|---|---|
| 1 seed × 1 locale × 10 suggestions | 10 | $0.06 |
| 10 seeds × 1 locale × 10 suggestions | 100 | $0.15 |
| 50 seeds × 2 langs × 1 country × 10 | 1,000 | $1.05 |
| 100 seeds × 1 locale × 15 suggestions | 1,500 | $1.55 |
| 10 seeds × 1 locale × A–Z expansion (27×10) | 2,700 | $2.75 |
| 100 seeds × 1 locale × A–Z expansion × 15 | 40,500 | $40.55 |

That's about $1 per 1,000 long-tail keywords — typically 10–50× cheaper than the closest keyword-research SaaS that wraps the same endpoint.

### 🚧 Limitations

- **Suggest endpoint, not SERP.** This Actor returns autocomplete suggestions — the dropdown under the search box. It does not scrape the actual Google search results page. For SERP scraping use a dedicated SERP Actor.
- **No search-volume data.** Google Suggest does not return monthly search-volume estimates — only the suggestions themselves. Pair with a keyword-volume Actor or Google Keyword Planner for volume.
- **Locale is a request hint, not a guarantee.** Google reserves the right to return general suggestions when locale-specific signal is sparse; obscure seeds in long-tail locales may return small or empty suggestion lists.
- **A–Z expansion only.** This Actor expands seeds with `a..z` suffixes. Number suffixes (`0..9`), question modifiers (`why`, `how`, `when`), or comparison modifiers (`vs`, `or`) are not built-in — they can be passed as explicit seeds.
- **Concurrency capped at 2.** The Actor deliberately limits in-flight requests to stay well below Google's documented 100/sec naive rate limit. Very large runs (10k+ tuples) will take time; budget accordingly.
- **7-day default storage retention** on the Apify FREE tier. Export your dataset immediately after the run or upgrade for longer retention.
- **No private / signed-in suggestions.** Personalized suggestions tied to a Google account are out of scope — this Actor reflects the unauthenticated public Suggest endpoint.

### ❓ FAQ

**Where do these suggestions come from?**

Directly from Google's public Suggest endpoint at `suggestqueries.google.com/complete/search` — the same endpoint Chrome and Firefox call when you type in the address bar. The response is a JSON array of up to 15 suggestions per query (chrome client) or 10 (firefox client). No browser automation, no SerpApi, no scraping of the SERP page.

**What is alphabet expansion and why does it matter?**

Alphabet expansion is the canonical long-tail discovery technique used by every major keyword-research tool. For each seed, the Actor also queries `<seed> a`, `<seed> b`, …, `<seed> z` — 26 extra calls. This surfaces the most common queries that start with your seed plus any next letter. For example, `best laptop` returns 15 generic suggestions; `best laptop a` returns suggestions like "best laptop accessories", "best laptop antivirus", "best laptop apple"; `best laptop b` returns "best laptop brands", "best laptop bag", and so on. One seed × 26 letters × 15 suggestions = up to 390 long-tail keywords per locale.

**Should I pick chrome or firefox?**

`chrome` (default) is the better choice for most use cases — it returns up to 15 suggestions (50% more than firefox), plus the `google:suggestrelevance` score (which loosely correlates with search-volume signal) and `google:suggesttype` tags. Pick `firefox` only when you specifically want the leaner 10-result payload without scores.

**Do I need Apify Proxy?**

Generally no. Google Suggest is tolerant of datacenter IPs and the Actor runs at conservative concurrency (2 in-flight requests). Enable `useProxy` only if you are running very large alphabet-expansion jobs (>2,000 tuples) and hit rate limits — the Actor will honour `Retry-After` headers but a proxy reduces the chance of throttling.

**How many requests does one run make?**

`len(seeds) × len(languages) × len(countries) × (1 + 26 if alphabet expansion else 1)` API calls. Each call returns up to 15 rows. So 10 seeds × 1 locale × A–Z = 270 calls → up to 4,050 rows.

**Is this legal?**

The Google Suggest endpoint is a public, unauthenticated HTTP API designed for browsers and developer tools to embed Google autocomplete in their UIs. There is no authentication, no rate-limit token, and no API-key requirement. Always verify your jurisdiction's data-protection rules and Google's Terms of Service before reselling raw suggestion data — most commercial keyword-research products use this same endpoint under the same conditions.

### 💬 Your feedback

Found a bug, hit a rate limit, or need a new field on the output row? Open an issue on the Actor's Apify Store page or contact the Devil Scrapes team at [apify.com/DevilScrapes](https://apify.com/DevilScrapes). We ship updates within days of validated reports.

# Actor input Schema

## `seeds` (type: `array`):

1–500 seed queries. The Actor fans each seed across every language × country combination below.

## `languages` (type: `array`):

ISO-639-1 lowercase language codes used for the <code>hl</code> parameter (e.g. <code>en</code>, <code>de</code>, <code>fr</code>, <code>ja</code>).

## `countries` (type: `array`):

ISO-3166-1 alpha-2 lowercase country codes used for the <code>gl</code> parameter (e.g. <code>us</code>, <code>de</code>, <code>gb</code>, <code>jp</code>).

## `client` (type: `string`):

Suggest endpoint client variant. <code>chrome</code> returns up to 15 suggestions plus relevance scores and subtypes (richest). <code>firefox</code> returns up to 10 suggestions with a leaner payload.

## `maxSuggestionsPerSeed` (type: `integer`):

Cap suggestions returned per (seed × language × country) tuple. Applied after the API response is parsed; never multiplies API calls.

## `enableAlphabetExpansion` (type: `boolean`):

If enabled, also query <code>\<seed> a</code>, <code>\<seed> b</code>, …, <code>\<seed> z</code> per seed — 26 extra calls per seed × locale for deep long-tail discovery.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy (BUYPROXIES94952). Google Suggest is generally tolerant of datacenter IPs — leave disabled unless you are hitting rate limits.

## Actor input object example

```json
{
  "seeds": [
    "best laptop",
    "best espresso machine"
  ],
  "languages": [
    "en"
  ],
  "countries": [
    "us"
  ],
  "client": "chrome",
  "maxSuggestionsPerSeed": 10,
  "enableAlphabetExpansion": false,
  "useProxy": false
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "seeds": [
        "best laptop",
        "best espresso machine"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/google-autocomplete-bulk").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 = { "seeds": [
        "best laptop",
        "best espresso machine",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/google-autocomplete-bulk").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 '{
  "seeds": [
    "best laptop",
    "best espresso machine"
  ]
}' |
apify call devilscrapes/google-autocomplete-bulk --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=devilscrapes/google-autocomplete-bulk",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Autocomplete Bulk Scraper",
        "description": "Bulk-fetch Google Autocomplete suggestions for any list of seed keywords across the country and language matrix you choose. We rotate browser fingerprints, route via Apify Proxy, retry with backoff, and return one clean typed row per (seed, country, lang, suggestion).",
        "version": "0.1",
        "x-build-id": "EqYcdKelLPmmqD7VM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~google-autocomplete-bulk/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-google-autocomplete-bulk",
                "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/devilscrapes~google-autocomplete-bulk/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-google-autocomplete-bulk",
                "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/devilscrapes~google-autocomplete-bulk/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-google-autocomplete-bulk",
                "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": [
                    "seeds"
                ],
                "properties": {
                    "seeds": {
                        "title": "Seed queries",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "1–500 seed queries. The Actor fans each seed across every language × country combination below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languages": {
                        "title": "Language codes",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "ISO-639-1 lowercase language codes used for the <code>hl</code> parameter (e.g. <code>en</code>, <code>de</code>, <code>fr</code>, <code>ja</code>).",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "en"
                        ]
                    },
                    "countries": {
                        "title": "Country codes",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "ISO-3166-1 alpha-2 lowercase country codes used for the <code>gl</code> parameter (e.g. <code>us</code>, <code>de</code>, <code>gb</code>, <code>jp</code>).",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "client": {
                        "title": "Suggest client",
                        "enum": [
                            "chrome",
                            "firefox"
                        ],
                        "type": "string",
                        "description": "Suggest endpoint client variant. <code>chrome</code> returns up to 15 suggestions plus relevance scores and subtypes (richest). <code>firefox</code> returns up to 10 suggestions with a leaner payload.",
                        "default": "chrome"
                    },
                    "maxSuggestionsPerSeed": {
                        "title": "Max suggestions per seed",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Cap suggestions returned per (seed × language × country) tuple. Applied after the API response is parsed; never multiplies API calls.",
                        "default": 10
                    },
                    "enableAlphabetExpansion": {
                        "title": "Enable A–Z alphabet expansion",
                        "type": "boolean",
                        "description": "If enabled, also query <code>&lt;seed&gt; a</code>, <code>&lt;seed&gt; b</code>, …, <code>&lt;seed&gt; z</code> per seed — 26 extra calls per seed × locale for deep long-tail discovery.",
                        "default": false
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy (BUYPROXIES94952). Google Suggest is generally tolerant of datacenter IPs — leave disabled unless you are hitting rate limits.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```