Google Autocomplete Scraper

Collect live Google Autocomplete suggestions for your seed keywords. Choose a language and country preference. Each saved row shows the suggestion, the Google query that returned it and its position in that response.

Use the rows for keyword research inputs, content ideas or search interface research. Pricing is $0.001 per start + $0.05 per 1,000 saved suggestions. Google can return an empty list. Requests can also fail or stop at a limit; check RUN_SUMMARY to see the reason.

Table of contents

• What it does
• Quick start
• Use cases
• Input
• Output
• Pricing and limits
• API and export
• Troubleshooting
• FAQ
• Support

What it does

The Actor sends direct HTTPS requests to Google's public Autocomplete endpoint. No Google login, Google API key, browser or proxy setup is needed. This endpoint is not an official bulk API and may change.

Choose exact to send each seed as entered after space cleanup. You can also add letters, numbers or question prefixes. The Actor saves unique suggestions and keeps the first query that returned each one. It does not expand returned suggestions again.

Good fit

• Find phrases to review when you plan an article or product page.
• Compare suggestion lists for the same seed with different language and country preferences.
• Export suggestions with their seed and query for your own search interface research.

Limits of the data

This Actor returns Google Search suggestions. It does not return search results, website rankings, search volume, CPC, Google Ads data or AI-generated keywords. It has no YouTube, Amazon, Places, Maps or recursive mode.

Suggestions can change with time, location, language and Google's filters. Country and language are request preferences. They do not set the request's IP location or guarantee a language for every result. The Actor does not give a complete keyword list or predict SEO rankings. Google explains how Autocomplete works.

Quick start

1. Open Input in Apify Console.
2. For a new form, keep the small prefill: keywords: ["coffee"], language: "en", country: "us", client: "chrome", and expansionModes: ["exact"].
3. Keep maxResults: 100 for the demo. Set a maximum cost per run in Apify if you need a platform charge cap.
4. Click Start.
5. Open Output → Suggestions or the default Dataset. Check suggestion, seed, generatedQuery and googleRank. Open Run summary for empty responses, errors and limits.

The form prefill is a demo. The runtime maxResults default is 500. An API input {} has no demo seed and fails validation. Console may restore your previously saved input; check it before starting.

Use cases

Job	Settings	Fields to use	Next step
Content ideas	keywords, expansionModes: ["exact", "questions"]	suggestion, generatedQuery, expansionToken	Review phrases in your content plan.
Locale comparison	Repeat the same keywords with different language / country	seed, language, country, googleRank, fetchedAt	Compare snapshots; differences are not search-volume measurements.
Search interface research	expansionModes: ["exact"]	suggestion, seed, googleRank	Use the exported list in your own analysis or prototype.

Input

All input fields

There are no nested input objects. All fields except keywords are optional.

Field	Type	Runtime default	New form prefill	Allowed values and effect
keywords	array of strings; required	None	["coffee"]	1–100 seeds, each up to 120 Unicode characters. Trim spaces and join repeated whitespace. Keep punctuation and Unicode.
language	string	"en"	"en"	Lowercase language code such as en, fr, ru, ja, pt-br. Two or three letters with an optional 2–8 character subtag. Sent as hl.
country	string	"us"	"us"	Two-letter code such as us, gb, fr, ru, jp. Lowercased and sent as gl.
client	string	"chrome"	"chrome"	chrome or firefox. Lists and metadata can differ. No browser is launched.
expansionModes	array of strings	["exact"]	["exact"]	At least one of exact, alphabet, numbers, questions. Repeated modes are used once.
questionPrefixes	array of strings	["how", "what", "where", "why", "when", "which"]	None	1–20 nonempty prefixes, each up to 40 characters. Trimmed and lowercased. Used by questions. Validation still applies when that mode is off.
maxGeneratedQueries	integer	50	50	1–500 planned Google queries. Retries are extra HTTP attempts.
maxResults	integer	500	100	1–5,000 saved unique rows. Stops additional row writes at the cap.
maxConcurrency	integer	4	4	1–8 simultaneous requests. Does not change row order.
requestTimeoutMillis	integer	8,000	None	1,000–30,000 ms per request attempt, also bounded by the remaining source deadline.
maxRetries	integer	1	None	0–2 retries for network, timeout and transient server errors. Blocks, redirects, rate limits and invalid payloads are not retried.
maxResponseBytes	integer	65,536	None	1,024–262,144 bytes per response. An oversized response is a technical failure.
maxRunTimeSeconds	integer	240	None	5–300 seconds for source work. A shorter platform deadline also applies, with time reserved for saving output. A larger platform timeout does not extend this input limit.
includeRawMetadata	boolean	true	None	Keep Google metadata when available. false saves {} in metadata.
maxChargeUsd	number	None	None	Form range: 0.00005–1.50 USD. Optional estimate cap for saved suggestion events. It does not cap platform usage or source requests.

For older API callers, seedKeywords remains an alias when keywords is absent. Runtime also accepts a comma- or newline-separated string for either seed field. The form uses an array. API numeric settings also accept numeric strings. Unknown extra keys have no runtime effect; the form schema disallows them.

Missing seeds, an empty array, a batch over 100 entries, non-string seeds or invalid settings produce a failed summary before any Google request. Empty-after-trimming or overlong seeds are recorded individually as invalid_input. Valid seeds in that batch can still run; invalid-only batches save no suggestion rows. Blank language/country/client values use their defaults. Optional numeric null values use their defaults.

Interacting settings

Setting	Behavior
Expansion	exact: the seed; alphabet: seed + space + a–z; numbers: seed + space + 0–9; questions: prefix + space + seed. Queries over 150 characters are skipped and reported.
Query cap	Plan seeds in input order, then modes in selected order. Keep at most maxGeneratedQueries. A query-plan limit gives stopped, even if all retained requests succeed.
Row / charge cap	Requests are fetched before rows are saved. A low maxResults or maxChargeUsd does not reduce that query plan. Keep the query cap small too.
Duplicate seeds or expansion paths	Dedupe suggestions within the same normalized seed, language, country, client and surface. Keep the first query's provenance. The same suggestion under another seed can be a separate row.
Request completion	Save rows in query-plan order, then Google response order. Concurrent completion order does not change grouping.

Example: three seed keywords

This input produced the output example below in a live Cloud run:

{
  "keywords": ["coffee", "café & bakery", "кофе"],
  "language": "en",
  "country": "us",
  "client": "firefox",
  "expansionModes": ["exact"],
  "maxResults": 30,
  "maxConcurrency": 2,
  "maxRetries": 1
}

The observed run saved 30 rows. That count is an example, not a promise for another run. Each row's seed and generatedQuery identify its input.

Example: bounded question expansion

{
  "keywords": ["coffee"],
  "expansionModes": ["exact", "questions"],
  "questionPrefixes": ["how", "what"],
  "maxGeneratedQueries": 3,
  "maxResults": 100
}

This plans coffee, how coffee and what coffee. It does not expand their results again. More queries can add source work and saved-row charges.

Output

Dataset fields

Each row is a saved useful suggestion. Error and empty outcomes are in RUN_SUMMARY, not extra Dataset rows. The runtime emits all fields below.

Field	Type	Meaning / empty values
id	string	Synthetic sug_ ID from normalized suggestion and first saved query/context. Google supplies no suggestion ID. Stable for the same text and path; a different first path can change it.
suggestion	string	Google suggestion text after JSON decoding. No HTML extraction, translation or scoring is applied.
normalizedSuggestion	string	Trimmed text with joined whitespace and lowercase letters, used for dedupe.
seed	string	Accepted seed after whitespace cleanup.
normalizedSeed	string	Seed used for planning; same whitespace cleanup, not lowercased.
generatedQuery	string	Exact query sent to Google.
expansionMode	string	exact, alphabet, numbers or questions.
expansionToken	string or null	Added letter, number or question prefix. null for exact.
language	string	Requested hl; not detected result language.
country	string	Requested gl; not a measured user or IP location.
client	string	chrome or firefox.
surface	string	Always web.
googleRank	integer	One-based position in this query's suggestion response. It is not a website search ranking. Dedupe can leave gaps.
sourceUrl	string	Fixed Google HTTPS origin and parameters. q is <redacted>; use generatedQuery for your query provenance.
sourceRequestId	string	Synthetic req_ ID for seed index, query and context. Moving a seed in the input can change it.
fetchedAt	ISO UTC string	Time the row was assembled after source work; not the time a suggestion was first created by Google.
metadata	object	Per-suggestion google: metadata with the prefix removed. Keys/values can change; missing values can be null. {} when unavailable or disabled. Relevance/type/subtype values are undocumented, not search volume.
duplicateOf	string or null	null in current output. Duplicate rows are skipped.

Output surfaces and run summary

Surface	What it contains
Default Dataset	Full suggestion rows. The Suggestions view shows selected columns. Use the full Dataset API/export for all fields.
Output → suggestions	A generated link to the Dataset Suggestions view.
Output → runSummary	A generated link to the KVS RUN_SUMMARY JSON record.
KVS INPUT	The input saved for the run.
KVS RUN_SUMMARY	Final input, status, limits, counters, timing, event estimate and non-row outcomes.

The output schema generates the two links. The Actor does not write a separate OUTPUT record. An absent OUTPUT record is expected.

RUN_SUMMARY has these fields:

Field / group	Contents
schemaVersion, status, verdict	Version 1, status succeeded / partial / stopped / failed, and a short explanation.
startedAt, finishedAt, durationMs, input	ISO UTC times, milliseconds and normalized input fields listed above.
limits	Booleans: maxGeneratedQueriesReached, maxResultsReached, maxChargeReached, maxRunTimeReached. Query-length skips share the generated-query limit flag.
counts	receivedSeeds, validSeeds, invalidInputs, generatedQueriesPlanned, generatedQueriesSkipped, attemptedRequests, savedSuggestions, duplicatesSkipped, emptyResponses, technicalFailures, retries, bytesDownloaded. Logical requests and retries are separate; bytes include retry response bodies.
performance	timeToFirstUsefulRowMs is time to the first assembled row after fetching the plan, not first persisted output. Source latency: p50SourceLatencyMs, p95SourceLatencyMs; usefulSuggestionsPerMinute uses core duration. Values can be null when no row/request exists.
pricing	Suggestion-event fields: eventName, pricePerSuggestionUsd, chargeableEvents, row-only estimatedChargeUsd, maxChargeUsd (number or null), chargingApplied (boolean). When the standard start event is active, platformStart reports its automatic estimate and estimatedTotalChargeUsd includes start plus rows. These are estimates, not a customer invoice.
source	host, transport, client, language, country, parserVersion.
outcomes	Non-row outcomes with kind, message, and optional seed, generatedQuery, sourceRequestId, count, statusCode. Optional fields can be absent. Your queries are kept here for your own run analysis.
warnings	Completeness, affiliation and charging notices.

Output example

This is one full row from the three-seed Cloud input above. Suggestions and their positions may change.

{
  "id": "sug_ea5550cf9d7b9437389da039680feb79",
  "suggestion": "coffee near me",
  "normalizedSuggestion": "coffee near me",
  "seed": "coffee",
  "normalizedSeed": "coffee",
  "generatedQuery": "coffee",
  "expansionMode": "exact",
  "expansionToken": null,
  "language": "en",
  "country": "us",
  "client": "firefox",
  "surface": "web",
  "googleRank": 1,
  "sourceUrl": "https://suggestqueries.google.com/complete/search?client=firefox&q=%3Credacted%3E&hl=en&gl=us",
  "sourceRequestId": "req_a11bd8afbabbaa481657418166b901ac",
  "fetchedAt": "2026-10-08T16:49:44.091Z",
  "metadata": {
    "suggestsubtypes": [
      512,
      433
    ]
  },
  "duplicateOf": null
}

Empty, partial and failed output

• succeeded: all retained planned requests completed. An empty Dataset with emptyResponses > 0 can be a valid result.
• partial: some seeds or source requests failed. Useful rows from other queries remain available.
• stopped: a query, length, row, charge or time limit prevented further work or writes. Already fetched requests remain in the counters.
• failed: invalid-only input, resource error, technical failure or internal error prevented useful output. Check outcomes.

The Apify run status and RUN_SUMMARY.status are separate. A completed process can be SUCCEEDED while the summary reports failed or stopped. Check the Dataset and the summary.

Pricing and limits

The price is $0.001 per Actor start + $0.00005 per saved unique suggestion: $0.05 per 1,000 rows. Apify charges the standard start event automatically, once at the supported 256–1,024 MB memory range. Empty and invalid-only runs still have the start charge. Duplicates, invalid seeds, empty lists and failed requests have no suggestion-event charge. Partial runs pay the start charge plus only the rows saved before completion or a cap.

Scenario	Saved suggestion events	Actor event charge
Three-seed exact run with 30 rows	30	$0.00250
Example one-seed run with 15 saved rows	15	$0.00175
Valid empty or invalid-only run	0	$0.00100
Partial/limited run with 2 saved rows	2	$0.00110
1,000 saved rows in one run	1,000	$0.05100
Maximum 5,000 saved rows in one run	5,000	$0.25100

These amounts include one start and the saved suggestion events. Check Console's cost details for the applied price and plan rules. A zero-result run still uses compute and storage. See Apify pay-per-event pricing.

For a cap on total Actor charges, use Apify's maximum cost per run (maxTotalChargeUsd in API calls); the minimum is $0.00105 for one start and one suggestion. maxChargeUsd is a separate estimate for suggestion events only, excluding the start. RUN_SUMMARY.pricing.estimatedChargeUsd preserves that row-only meaning; when the start event is active, platformStart and estimatedTotalChargeUsd show the additional start estimate and total. These estimates are not a customer invoice. Neither limit guarantees every planned query will run or every returned suggestion will be saved.

Hard limits: 100 seeds, 120 characters per seed, 150 per generated query, 500 planned queries, 5,000 saved rows, concurrency 8, two retries and 262,144 bytes per response. The schema sets default memory to 512 MB and supports 256–1,024 MB. A larger platform timeout keeps the internal source limit unchanged. This Actor has no output-text filter or stateful unchanged/delta mode.

API and export

Use the Actor's API tab to start a run with the same input fields. Read its default Dataset after it finishes. Keep your Apify API token in a private credential store, not in shared links or input examples.

Export the Dataset as JSON or CSV in Console. Use suggestion, seed and generatedQuery as the next step's text fields. Keep id, locale and fetchedAt when comparing snapshots. Apify documents the run-and-retrieve flow.

Apify can schedule runs through its platform. Each run creates a fresh snapshot; this Actor does not maintain a change baseline. Repeated runs can return and charge the same current suggestions. No schedule is enabled by using this Actor.

Troubleshooting

Symptom	What to check	Safe next action
Empty Dataset	status, emptyResponses, technicalFailures, outcomes	Try a clear public seed only when the summary confirms a valid empty response.
invalid_input	Seed count/length and allowed settings	Correct the input; do not add a login or token.
blocked_or_consent, rate_limited	Access denial, HTML or redirects	Stop repeated runs. Retry later with a small query plan and lower concurrency.
malformed_response	Unexpected JSON, suggestion types or a different echoed query	Share the run ID with support. Do not treat it as an empty suggestion list.
retry_exhausted	Timeout/network/server failure after bounded attempts	Use fewer queries or lower concurrency; check the summary before retrying.
response_too_large	Response size exceeded maxResponseBytes	Check for source drift; increase the byte cap only within the documented range.
stopped with useful rows	limits and outcomes	Export the rows already saved. Increase only the specific limit you need.
resource_error	Memory outside 256–1,024 MB	Choose supported memory. This is separate from invalid input.
Different suggestions on repeat	Time, locale, client and query paths	Compare snapshots, not a promised permanent keyword set.

FAQ

Do I need a Google account or Google API key?

No. An Apify account is needed to run the Actor. No Google credentials are used.

Are these search volumes or Google Search rankings?

No. googleRank is a position inside an Autocomplete response. Metadata does not provide verified search volume, CPC or competition.

Can I use non-English keywords?

Yes. Unicode is kept, including Cyrillic and accented text. Set the requested language and country. Google can still return suggestions in another language.

Are country results exact local results?

No. country sends gl; it does not change IP location. Results can also depend on Google's current behavior.

Will a repeat run have the same IDs and order?

The same saved text and first query/context have the same synthetic ID. Query-plan grouping is deterministic. Google's suggestion text and order can change, and a different first expansion path can change an ID.

Why did a low row limit still make several requests?

The Actor fetches its bounded query plan before saving rows. Lower maxGeneratedQueries when you also need fewer source requests.

Do empty runs cost nothing?

No. The $0.001 start event still applies. There is no suggestion event when no useful row is saved. Check the actual cost breakdown in Console.

Can it monitor changes or expand recursively?

It can export repeated snapshots, but it has no built-in delta state, unchanged-result filter or recursive expansion. Compare exported snapshots in your own workflow.

Support

Open an issue in this Actor's Apify Issues tab. Include the run ID, selected mode, non-sensitive input settings and the relevant RUN_SUMMARY outcome. Remove private keywords if needed. Never share API tokens, cookies, account or billing details.

This project is not affiliated with, endorsed by, or sponsored by Google. The Google name identifies the source. The published icon is kept; no new images are needed to use the input or read the output.