Google Search Autocomplete Scraper

Google Autocomplete Scraper — Keyword Suggestions and Expansion

Google Autocomplete Scraper queries Google's real-time suggestion endpoint and returns one JSON row per keyword: the query you sent, every suggestion Google returned — as flat suggestion_01…suggestion_NN fields and as a suggestions array — plus a suggestionCount. Suggestions can be localized to 77 languages and 69 countries, and the usePrefix/useSuffix options sweep a–z variants through the same seed to widen coverage. Built for SEO keyword researchers, content strategists and PPC marketers who need bulk, structured autocomplete data without hitting Google's endpoint by hand.

⚠️ usePrefix and useSuffix multiply the queries — and every query is a billed row

This is the one input decision that changes your run's cost and size the most, so it belongs up front rather than buried in the parameter table.

Each base keyword you enter always runs once. Turning on usePrefix adds 26 more variants — one letter of the alphabet placed before the keyword (a apple, b apple, … z apple). Turning on useSuffix adds another 26 — one letter placed after (apple a, apple b, … apple z). With both enabled, one seed keyword becomes up to 53 separate queries (1 original + 26 prefix + 26 suffix), and the Actor charges one row_result event per query — including queries that come back with zero suggestions. There is no free or uncharged row in this Actor; every row pushed to the dataset is a billed event, whether it carries ten suggestions or none.

A concrete example: 5 seed keywords with usePrefix on and useSuffix off run as 5 × 27 = 135 queries, and therefore 135 billed row_result events, before a single suggestion is even read. Add useSuffix on top of the same 5 seeds and the run becomes 5 × 53 = 265 billed events.

What is Google Autocomplete Scraper?

Google Autocomplete Scraper is an Apify Actor that calls Google's live search-suggestion endpoint for a list of keywords and returns the predictions Google would show as you type them into the search box. No Google account, login or API key is required — the Actor sends anonymous requests, exactly like a browser typing into the search bar.

• Keywords are supplied as a plain list (queries) — one seed per line, any number of seeds in one run
• Each row carries the query and its suggestions, both as numbered flat fields and as a suggestions array
• suggestionCount tells you how many suggestions a given query returned, so you can sort or filter seeds by yield
• language and country localize the suggestion set to a specific market, out of 77 languages and 69 countries
• usePrefix and useSuffix expand a single seed into an a–z sweep for broader keyword discovery
• Requests fall back through a no-proxy → datacenter → residential proxy ladder automatically if Google starts blocking a run
• Results are stored in the Apify dataset and can be exported as JSON, CSV or Excel, or read through the Apify API

What data can I extract with Google Autocomplete Scraper?

Every row returned by the Actor carries the query, its suggestions in two parallel shapes, and a count — no derived scoring, no sentiment tagging, no third-party enrichment layered on top of what Google itself returned.

Field Name	Example Value	Use Case
query	"best laptops 2024"	The exact string sent for this row — the base seed, or the expanded variant (e.g. "a best laptops 2024") if prefix/suffix expansion is on
suggestion_01 … suggestion_NN	"best laptops 2024 for students"	One field per suggestion Google returned, zero-padded and numbered in Google's own order
suggestions	["best laptops 2024 for students", "best laptops 2024 under 1000", ...]	The same suggestion strings as an array, for programmatic iteration instead of reading fixed column names
suggestionCount	8	Count of suggestions returned for this query (0 if Google returned none)

That is the complete field set — four base keys, plus as many suggestion_NN keys as a given query actually returned. There is no separate metadata object, no nested pagination cursor, and no nulls standing in for missing suggestions; a row is exactly as wide as the data it actually has.

Suggestion strings

suggestion_01 through suggestion_NN and the suggestions array carry the actual autocomplete text — the long-tail phrases, questions and modifiers Google's own algorithm associates with the seed. This is the data keyword research and content ideation are built on. Only as many suggestion_NN keys are written as there are suggestions: a query that returns 4 suggestions has suggestion_01 through suggestion_04 and no suggestion_05 key at all — the field is omitted, not returned as an empty string or null. Reading from the suggestions array avoids having to check which numbered keys exist on a given row.

Query identity and volume

query and suggestionCount are the two fields you filter and sort on. query tells you which seed — or which prefix/suffix variant of a seed — a row belongs to, since expansion turns one input keyword into dozens of query rows. suggestionCount lets you rank seeds by how many suggestions they yielded, or isolate the zero-suggestion rows that a broad a–z sweep inevitably produces.

Suggestions themselves keep Google's own return order — suggestion_01 is always the first entry in Google's response array, suggestion_02 the second, and so on, and the suggestions array preserves that same order. Neither field is re-sorted, deduplicated, or scored by the Actor; whatever order and set Google's endpoint hands back is what gets written to the row.

Why not build this yourself?

Google does not publish a public API for autocomplete. The endpoint every scraper — including this one — actually calls, suggestqueries.google.com/complete/search, is undocumented: no official docs, no versioning guarantee, no support channel if the response shape changes.

Building a reliable caller yourself means solving the same problems this Actor already solves. The endpoint needs a client=firefox query parameter to return plain JSON instead of a JSONP wrapper, and it returns a nested array ([query, [suggestions]]) rather than a keyed object. Localizing results means mapping every language and country you support to Google's own hl/gl codes — this Actor maintains that mapping for the 77 languages and 69 countries in its input schema. And detecting a soft block is its own problem: Google can return HTTP 200 with an empty or malformed body instead of an error status, so a naive caller reads that as "no suggestions" rather than "blocked." This Actor checks the response status, body content and JSON structure together, and escalates through a none → datacenter → residential proxy ladder — sticking with residential and retrying up to three times once it gets there — rather than returning an empty result on the first sign of trouble.

Under the hood, requests run through a connection pool capped at 20 concurrent connections (10 per host), with a 30-second total timeout and a 10-second connect timeout on every request — so a run degrades by retrying and falling back through proxy tiers instead of hammering the endpoint or hanging indefinitely on a stalled connection.

If you only need a handful of one-off lookups, calling the endpoint directly is fine. Once you need bulk seeds, multi-market localization, or a run that keeps working when Google starts pushing back, that's the maintenance load this Actor absorbs.

How to use data extracted from Google Autocomplete?

SEO keyword researchers and content teams

Feed a list of seed topics into queries, turn on usePrefix and useSuffix for full a–z coverage, and read suggestions per row to build a long-tail keyword list for a content calendar. Sorting by suggestionCount surfaces which seeds Google actually has depth on, so low-yield seeds can be dropped before they waste an editorial slot. Because every row keeps the original query string, a topic cluster of 20 seeds with both expansion flags on still comes back as one dataset you can group by seed and rank by suggestion volume, rather than 20 separate exports to reconcile by hand.

Agencies and service providers

Run the same queries list against a client's target market by setting country and language to match, then re-run monthly against the same seeds to track how Google's suggested phrasing shifts — useful evidence for a content-strategy retainer report without hand-checking the search bar for every keyword. Because the dataset is timestamped by run, exporting each month's results to a shared sheet builds a lightweight trend log per client without any extra tooling.

Market research and intelligence

Run identical seed keywords across multiple country/language pairs in separate runs and compare the suggestions arrays side by side to see how search intent for the same topic differs by market — a category-expansion signal that a single-market keyword tool cannot show. This works for competitor and category research too: seed the run with a competitor's brand name or a product category and read back what Google's own users are typing next.

AI agents and automated pipelines

Because output is typed JSON keyed by query, an agent tool can call the Actor with a topic list and get back a structured suggestion set to feed into a content-brief generator or a keyword-expansion step in a larger research pipeline — no parsing step required. The suggestions array in particular is ready to drop straight into a prompt as few-shot context or a retrieval candidate list, without first stripping numbered column names out of a flat row.

⬇️ Input

Parameter	Required	Type	Description	Example Value
queries	✅ Yes	array	Enter keywords or phrases — one per line. Add multiple for bulk scraping.	["how to lose weight", "best laptops 2024", "healthy breakfast ideas"]
language	No	string	Language of the suggestions. 77-value enum, default "English". Includes "English", "Spanish", "French", "German", "Italian", "Portuguese", "Russian", "Japanese", "Korean", "Chinese", "Arabic", "Hindi", and 65 more.	"English"
country	No	string	Target country for location-specific suggestions. 69-value enum, default "United States". Includes "United States", "United Kingdom", "Canada", "Australia", "Germany", "France", "Spain", "Italy", "Brazil", "Mexico", and 59 more.	"United States"
usePrefix	No	boolean	Add a-z before each keyword (e.g. a apple, b apple) for more results. Default false.	true
useSuffix	No	boolean	Add a-z after each keyword (e.g. apple a, apple b) for more results. Default false.	true
proxyConfiguration	No	object	Optional: Use proxies for higher volume or to avoid blocks.	{"useApifyProxy": true}

Example input

{
  "queries": [
    "how to lose weight",
    "best laptops 2024",
    "healthy breakfast ideas"
  ],
  "language": "English",
  "country": "United States",
  "usePrefix": false,
  "useSuffix": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Common pitfall: enabling both usePrefix and useSuffix on a long queries list is the fastest way to run up billed rows without realizing it — 10 seed keywords with both expansions on produce up to 530 query rows in one run, each charged as its own row_result event.

A second pitfall: proxyConfiguration is not applied to every request. Every query starts as a direct, proxyless request regardless of what proxyConfiguration is set to. Only if Google's response looks blocked (HTTP 403/429/503, an empty body, or an invalid response shape) does the Actor escalate — first to Apify's GOOGLE_SERP datacenter proxy group, then, if that is also blocked, to a residential proxy using whatever proxyConfiguration you supplied (or a default RESIDENTIAL group if you left useApifyProxy off), retrying up to three times once it reaches residential. Setting proxyConfiguration does not make the Actor route the first request of every query through your chosen proxy — it only takes effect once the fallback ladder reaches the residential tier.

⬆️ Output

Typed JSON, one row per query (base seed or expanded variant), written to the dataset as each query finishes. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

Example output

{
  "query": "best laptops 2024",
  "suggestion_01": "best laptops 2024 for students",
  "suggestion_02": "best laptops 2024 under 1000",
  "suggestion_03": "best laptops 2024 for gaming",
  "suggestion_04": "best laptops 2024 for college",
  "suggestion_05": "best laptops 2024 for programming",
  "suggestion_06": "best laptops 2024 reddit",
  "suggestion_07": "best laptops 2024 for video editing",
  "suggestion_08": "best laptops 2024 lightweight",
  "suggestions": [
    "best laptops 2024 for students",
    "best laptops 2024 under 1000",
    "best laptops 2024 for gaming",
    "best laptops 2024 for college",
    "best laptops 2024 for programming",
    "best laptops 2024 reddit",
    "best laptops 2024 for video editing",
    "best laptops 2024 lightweight"
  ],
  "suggestionCount": 8
}

A query with fewer suggestions simply has fewer suggestion_NN keys — there is no suggestion_09 or suggestion_10 key on this row, not a blank or null one. A query with zero suggestions returns suggestionCount: 0, an empty suggestions array, and no suggestion_NN keys at all — that row is still written and still charged.

The default dataset table only displays suggestion_01 through suggestion_10. The Actor itself does not cap suggestions at 10 — the field loop writes one suggestion_NN key for every suggestion Google returns, however many that is. But the dataset's built-in table view (.actor/actor.json → storages.dataset.views.default) only lists columns suggestion_01–suggestion_10, so on a query where Google returns an eleventh or twelfth suggestion, suggestion_11/suggestion_12 exist on the underlying row and inside the suggestions array, but will not appear as columns in the Console's default table — only in the JSON/CSV export or the API response. Read suggestions rather than the numbered columns if you need every suggestion Google returned, not just the first ten.

A row with an above-average suggestion count looks like this:

{
  "query": "best budget laptops",
  "suggestion_01": "best budget laptops 2024",
  "suggestion_02": "best budget laptops for students",
  "suggestion_03": "best budget laptops for gaming",
  "suggestion_04": "best budget laptops for programming",
  "suggestion_05": "best budget laptops under 500",
  "suggestion_06": "best budget laptops for college",
  "suggestion_07": "best budget laptops reddit",
  "suggestion_08": "best budget laptops with good battery life",
  "suggestion_09": "best budget laptops for video editing",
  "suggestion_10": "best budget laptops 2024 uk",
  "suggestion_11": "best budget laptops for photo editing",
  "suggestions": [
    "best budget laptops 2024",
    "best budget laptops for students",
    "best budget laptops for gaming",
    "best budget laptops for programming",
    "best budget laptops under 500",
    "best budget laptops for college",
    "best budget laptops reddit",
    "best budget laptops with good battery life",
    "best budget laptops for video editing",
    "best budget laptops 2024 uk",
    "best budget laptops for photo editing"
  ],
  "suggestionCount": 11
}

suggestion_11 is present in the row and in suggestions, but the Console table view stops at suggestion_10 — only the JSON export, CSV export, or the suggestions array surfaces it.

🌐 Supported languages and countries

language and country are both closed enums — the Actor accepts only the values listed in its input schema, and maps each one internally to the hl (language) and gl (country) code Google's own suggestion endpoint expects. The tables below are the full list from .actor/actor.json, not a sample.

Languages (77)

Language	Code	Language	Code	Language	Code	Language	Code
English	en	Spanish	es	French	fr	German	de
Italian	it	Portuguese	pt	Russian	ru	Japanese	ja
Korean	ko	Chinese	zh-CN	Arabic	ar	Hindi	hi
Bengali	bn	Turkish	tr	Vietnamese	vi	Polish	pl
Dutch	nl	Swedish	sv	Danish	da	Norwegian	no
Finnish	fi	Czech	cs	Hungarian	hu	Romanian	ro
Greek	el	Hebrew	iw	Thai	th	Indonesian	id
Malay	ms	Filipino	tl	Ukrainian	uk	Bulgarian	bg
Croatian	hr	Slovenian	sl	Slovak	sk	Lithuanian	lt
Latvian	lv	Estonian	et	Icelandic	is	Irish	ga
Welsh	cy	Basque	eu	Catalan	ca	Galician	gl
Afrikaans	af	Swahili	sw	Zulu	zu	Xhosa	xh
Amharic	am	Somali	so	Yoruba	yo	Hausa	ha
Igbo	ig	Persian	fa	Urdu	ur	Tamil	ta
Telugu	te	Kannada	kn	Malayalam	ml	Marathi	mr
Gujarati	gu	Punjabi	pa	Nepali	ne	Sinhala	si
Burmese	my	Khmer	km	Lao	lo	Mongolian	mn
Tibetan	bo	Georgian	ka	Armenian	hy	Azerbaijani	az
Kazakh	kk	Uzbek	uz	Turkmen	tk	Kyrgyz	ky
Tajik	tg

Countries (69)

Country	Code	Country	Code	Country	Code	Country	Code
United States	us	United Kingdom	uk	Canada	ca	Australia	au
Germany	de	France	fr	Spain	es	Italy	it
Brazil	br	Mexico	mx	Argentina	ar	Chile	cl
Colombia	co	Peru	pe	Russia	ru	Ukraine	ua
Poland	pl	Netherlands	nl	Belgium	be	Switzerland	ch
Austria	at	Sweden	se	Norway	no	Denmark	dk
Finland	fi	Portugal	pt	Ireland	ie	Czech Republic	cz
Hungary	hu	Slovakia	sk	Slovenia	si	Croatia	hr
Greece	gr	Bulgaria	bg	Romania	ro	Turkey	tr
China	cn	Japan	jp	South Korea	kr	India	in
Pakistan	pk	Bangladesh	bd	Indonesia	id	Malaysia	my
Thailand	th	Philippines	ph	Vietnam	vn	Singapore	sg
New Zealand	nz	South Africa	za	Egypt	eg	Nigeria	ng
Kenya	ke	Morocco	ma	Tunisia	tn	Algeria	dz
Saudi Arabia	sa	United Arab Emirates	ae	Israel	il	Jordan	jo
Lebanon	lb	Iran	ir	Iraq	iq	Kuwait	kw
Qatar	qa	Oman	om	Bahrain	bh	Yemen	ye
Syria	sy

country: "United Kingdom" maps to the code uk rather than the ISO 3166-1 alpha-2 gb. This is the value the Actor's source code sends as gl=uk on every UK-targeted request — worth knowing if you cross-reference this Actor's output against another tool that expects strict ISO country codes, since the two will not line up for the UK row even though both are asking Google for the same market.

How do you filter and target specific suggestions?

Precision here is less about narrowing a large catalogue and more about controlling which queries actually get sent, since every query sent is a billed row.

Direct query vs. expansion. A plain entry in queries gets you exactly Google's suggestions for that phrase — the fastest, cheapest way to check a single seed. usePrefix and useSuffix exist for when one seed isn't enough: they turn it into up to 53 variants to surface suggestions Google only shows once you've typed further, at the cost of up to 53x the rows and billed events.

Market precision. language and country together fix which market's autocomplete index you're reading — the same seed can return a meaningfully different suggestion set in "Spanish"/"Mexico" than in "English"/"United States". The two inputs are independent, so pairing "Spanish" with "country": "United States" reads a Spanish-speaking US audience directly. Run the same seeds across multiple language/country pairs in separate runs to compare markets.

Volume control. Total rows for a run is (seeds) × (1, 27, or 53) depending on which expansion flags are on. Multiply it out before enabling both flags on a long seed list — that number is exactly how many row_result events the run will charge.

{ "queries": ["project management software"], "language": "English", "country": "United States" }

{ "queries": ["yoga for beginners"], "usePrefix": true, "useSuffix": true }

{
  "queries": ["project management software", "task tracking app", "team collaboration tool"],
  "language": "English",
  "country": "United Kingdom"
}

🔗 Want to try other Google scrapers?

These SimpleAPI scrapers cover other Google surfaces and the adjacent SEO-metrics tools autocomplete research is usually paired with:

Scraper Name	What it extracts
Google News Scraper	News articles and headlines by search query
Google Maps Scraper By Radius & GeoJSON Territory	Local business listings within a radius or custom territory
Google Play Store Review Scraper & Developer Replies	App reviews, ratings and developer replies
Ahrefs Scraper & Competitor Comparison	Domain authority, traffic and keyword metrics from Ahrefs
MOZ Scraper (SEO Health Score)	Domain and page authority metrics from Moz
YouTube Channel Keyword Research Scraper	Keyword and content research data from YouTube channels

How to extract Google Autocomplete data programmatically

Google Autocomplete Scraper is an Apify Actor: one API call starts a run, and structured JSON lands in the dataset as each query finishes.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/google-search-autocomplete-scraper").call(run_input={
    "queries": ["best laptops 2024", "healthy breakfast ideas"],
    "language": "English",
    "country": "United States",
    "usePrefix": True,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["query"], row["suggestionCount"], row["suggestions"][:3])

The example above filters on usePrefix and pulls query, suggestionCount and the first three entries of suggestions straight out of the response — no separate parsing step, since the dataset row is already typed JSON. Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request against the Apify API.

Export to spreadsheets or CRM

CSV export maps query to a keyword column, suggestion_01 through however many suggestion columns a run produces to individual suggestion columns, and suggestionCount to a result-count column — ready to paste into Sheets or a keyword-tracking workflow. Because the numbered columns only go as high as the widest row in that particular export, pull from suggestions instead of a fixed set of suggestion_NN columns if your destination sheet or CRM field mapping needs to stay stable across runs with different suggestion counts.

Is it legal to scrape Google Autocomplete suggestions?

Yes. Reading Google's autocomplete suggestions is broadly treated as permissible because the suggestions are shown to any anonymous visitor typing into the public Google search box — no login, account or authentication is bypassed to see them.

Autocomplete strings are not personal data about any individual — they are Google's own algorithmically generated text tied to a search query, not a person's record. GDPR and equivalent personal-data regimes do not attach to this output the way they would to a profile or reviewer scraper. What does apply is Google's Terms of Service and any database rights Google may claim over the suggestion index, since the endpoint this Actor (and every similar tool) calls is not an officially published API.

Consult legal counsel before reselling extracted suggestion data as a standalone product or building a commercial keyword-research tool on top of it at scale.

❓ Frequently asked questions

What happens if a query returns zero suggestions?

The row is still written, with suggestionCount: 0, an empty suggestions array, and no suggestion_NN keys at all — and it is still charged as a row_result event. This is common on a–z sweep variants, since not every letter combination has suggestions in Google's index. Filter these out downstream, for example while iterating the dataset with apify_client:

zero_yield = [item["query"] for item in client.dataset(dataset_id).iterate_items() if item["suggestionCount"] == 0]

Can I get suggestions localized to a specific language and country?

Yes. language (77 values, default "English") and country (69 values, default "United States") are independent inputs — set both to match the market you're researching. The Actor maps each selection to Google's own language and country codes before requesting suggestions.

How accurate and fresh is the suggestion data?

The Actor returns exactly what Google's suggestion endpoint returns at the moment of the request — there is no caching or delay layer in between. Because Google's suggestions shift with real-time search trends, re-running the same query at a later date can return a different list.

How many suggestions can I get per query?

The Actor does not trim or cap the suggestion list itself — every suggestion in Google's response for that query is pushed to the row. How many suggestions Google's own endpoint returns for a given query is set by Google, not documented here, and can vary by query, language and country.

How do usePrefix and useSuffix affect how many rows and events I get billed for?

Each enables an a–z sweep of 26 variants: usePrefix prepends a letter and a space before the seed, useSuffix appends a space and a letter after it. One seed becomes 27 queries with either flag alone, or up to 53 with both — and each resulting query is its own charged row_result event, whether or not it returns any suggestions.

Does Google Autocomplete Scraper work with Claude, ChatGPT and other AI agent frameworks?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make a request — LangChain, CrewAI, n8n, a custom tool definition — can invoke it and receive typed JSON with no parsing step.

How does Google Autocomplete Scraper compare to other Google Autocomplete scrapers?

Checked on the Apify Store on 2026-07-25: scraper-mind/google-search-autocomplete-api documents the same one-row-per-query, suggestion_01-style output and is billed as a flat monthly subscription rather than pay-per-event, per their listing. lofomachines/google-search-autocomplete-cheaper-faster-reliable and riisager/google-search-suggest-autocomplete both document a one-row-per-suggestion output enriched with position, relevance_score, word_count, char_count and a scraped_at timestamp — metadata this Actor does not compute or return. This Actor's output stays close to Google's raw response: one row per query, suggestions available both as numbered columns and as a suggestions array, with no derived scoring fields.

Can I use Google Autocomplete Scraper without a Google API key or developer account?

Yes. Google has no official autocomplete API to hold a key for, and this Actor needs neither a Google account nor an API key — it sends the same anonymous request a browser makes. The only credential required is your Apify token to run the Actor itself.

Can I run bulk queries without triggering the prefix/suffix multiplier?

Yes. Leave usePrefix and useSuffix at their default false and add as many seeds to queries as you need — each seed then produces exactly one query row, with no a–z expansion.

Does setting proxyConfiguration route every request through a proxy immediately?

No. Every query's first request is sent without a proxy, regardless of what proxyConfiguration is set to. The Actor only reaches for a proxy after Google's response looks blocked — it escalates to Apify's GOOGLE_SERP datacenter group first, and only moves to a residential proxy (using your proxyConfiguration settings, or a default RESIDENTIAL group if none of your own is supplied) if the datacenter tier is also blocked. If you need every request proxied from the first attempt for compliance or consistency reasons, this Actor's fallback-on-demand behavior is the actual implementation to plan around.

Does the country I select change which Google domain the request goes to?

No. Every request — regardless of country — is sent to the same fixed hostname, suggestqueries.google.com, with the country expressed only through the gl query parameter Google's endpoint reads. The Actor never routes to a country-specific Google domain like google.co.uk or google.de; localization is entirely handled by the hl (language) and gl (country) parameters on that one endpoint.

Conclusion

Google Autocomplete Scraper turns Google's live suggestion endpoint into typed, structured JSON: one row per query, suggestions as both numbered fields and an array, localized to the language and country you choose. It's built for keyword researchers, content teams and agencies who need that data in bulk without maintaining their own endpoint caller, language/country code mapping, and proxy-fallback logic. The usePrefix/useSuffix sweep and the 77-language, 69-country coverage exist for the same reason: to turn a handful of seed keywords into as broad or as narrow a suggestion set as the run actually calls for, without a second tool or a manual re-check of the search bar. Open it on the Apify Console or call it through the Apify API to start a run.