# Google Autocomplete Scraper — Bulk (`devilscrapes/google-autocomplete-bulk`) Actor
Bulk Google Autocomplete (Suggest) scraper and API — run many seeds × languages × countries per run with optional A–Z expansion for long-tail keyword research. Export suggestions to JSON or CSV. Public Suggest endpoint, no auth, no key.
- **URL**: https://apify.com/devilscrapes/google-autocomplete-bulk.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 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
## Google Autocomplete Scraper — Bulk Suggest API
_We do the dirty work so your dataset stays clean._ 😈
**$1.05 / 1,000 suggestions** — Export real Google autocomplete suggestions for hundreds of seeds across many languages and countries in a single run. Optional A–Z alphabet expansion turns every seed into 26 long-tail variants. No SerpApi key. No Google account required.
Google's autocomplete dropdown is the canonical signal of what people are actually typing into the search box. Keyword-research SaaS tools 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 queries the endpoint directly, 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 google autocomplete scraper queries Google's 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 ` a`, ` b`, …, ` 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.
- **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.
- **We rotate browser fingerprints** — `curl-cffi` replays a real Chrome TLS+H2 fingerprint so requests look indistinguishable from a real browser, not a Python script.
- **We retry with exponential backoff** — 408 / 429 / 5xx responses trigger automatic retries (up to 5 attempts, honours `Retry-After`). You get results; we handle the turbulence.
- **We rotate proxies on block** — Apify Proxy is wired in; on any block a fresh session ID and fresh exit IP take over automatically.
- **Conservative concurrency** — 2 in-flight requests per run by default; the Actor backs off gracefully when the target rate-limits and surfaces partial results with a clear status message rather than returning an empty dataset.
- **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.
- **AnswerThePublic alternative** — get the same autocomplete suggestions direct from Google for a fraction of the cost. 1,000 suggestions = $1.05 here vs $89–199/mo for a SaaS dashboard that wraps the same endpoint.
- **PPC negative-keyword mining** — pull alphabet-expanded suggestions across the seed for your category, then filter for adjacent products or 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.
- **Free keyword research API replacement** — developers who were paying per-call for a keyword research API can replace that spend with a single Apify Actor at $1.05 per 1,000 results.
### ⚙️ 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 (` a` through ` z`).
7. Leave **Use Apify Proxy** off for most runs; enable it for large jobs (>2,000 tuples) if you encounter rate limits — the Actor will use a fresh session and exit IP automatically.
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 | yes | — | 1–500 seed queries |
| `languages` | array | no | `["en"]` | ISO-639-1 lowercase language codes |
| `countries` | array | 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 ` a` through ` 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, on pay-per-result pricing with no monthly subscription for the keyword-research the SaaS tools wrap.
### 🚧 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 may 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 within the Suggest endpoint's tolerances. 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.** Personalised 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).
**Is this a google suggest scraper or does it use an official API?**
The endpoint is a public, browser-facing API — not a signed Google Cloud product. It has no API key requirement and is designed for browser clients. We treat it like what it is: a well-known endpoint that can throttle heavy callers. That is why we run conservative concurrency, rotate fingerprints, and retry with backoff so you get reliable bulk output.
**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 ` a`, ` b`, …, ` 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 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 for every run?**
Not for typical runs. The Actor runs at conservative concurrency (2 in-flight requests) with automatic retry on rate-limit responses. Enable `useProxy` for very large alphabet-expansion jobs (>2,000 tuples) — the Actor will route through Apify Proxy, rotating the session on any block so the job keeps running.
**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 an AnswerThePublic alternative?**
Yes, it hits the same underlying Google Suggest data source that powers AnswerThePublic, KeywordTool.io, and Ubersuggest. The difference: you get raw bulk export across any locale or seed list at $1.05 per 1,000 suggestions instead of a fixed SaaS monthly seat. No dashboard, no limit on seed volume.
**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. 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 hl parameter (e.g. en, de, fr, ja).
## `countries` (type: `array`):
ISO-3166-1 alpha-2 lowercase country codes used for the gl parameter (e.g. us, de, gb, jp).
## `client` (type: `string`):
Suggest endpoint client variant. chrome returns up to 15 suggestions plus relevance scores and subtypes (richest). firefox 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 \ a, \ b, …, \ z 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 '' with your token
const client = new ApifyClient({
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 '' with your token.
client = ApifyClient("")
# 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 "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Google Autocomplete Scraper — Bulk",
"description": "Bulk Google Autocomplete (Suggest) scraper and API — run many seeds × languages × countries per run with optional A–Z expansion for long-tail keyword research. Export suggestions to JSON or CSV. Public Suggest endpoint, no auth, no key.",
"version": "0.1",
"x-build-id": "Q062evuObpGzhqarw"
},
"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 hl parameter (e.g. en, de, fr, ja).",
"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 gl parameter (e.g. us, de, gb, jp).",
"items": {
"type": "string"
},
"default": [
"us"
]
},
"client": {
"title": "Suggest client",
"enum": [
"chrome",
"firefox"
],
"type": "string",
"description": "Suggest endpoint client variant. chrome returns up to 15 suggestions plus relevance scores and subtypes (richest). firefox 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 <seed> a, <seed> b, …, <seed> z 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
}
}
}
}
}
}
}
}
}
}
```