Google Search Autocomplete Scraper With Negative Suggestions

Google Autocomplete Scraper — Brand Reputation & Negative Suggestions

Google Search Autocomplete Scraper With Negative Suggestions queries Google's own suggest endpoint for any brand, product, or person, then classifies every completion it gets back — flagging the ones that contain a risk word ("scam," "lawsuit," "recall," "reviews"…) so you see reputation damage the moment Google starts surfacing it. Every run returns typed, structured JSON: the raw suggestion list, Google's own relevance and type score for each entry, and a reputation rollup (hasNegative, negativeCount, topNegativeCompletion) ready to drop into a monitoring dashboard, a spreadsheet, or an LLM prompt. Point it at one brand or a hundred, on a schedule, and watch how autocomplete — and the risk terms attached to it — shifts over time.

What is Google Search Autocomplete Scraper With Negative Suggestions?

It's a Google autocomplete scraper built around one job: telling you when Google's own suggest box starts associating your brand with something damaging. Give it a list of brand names or keywords and it queries Google's public suggestqueries.google.com/complete/search endpoint (the same one Chrome's address bar calls) for each one, then — in its default Reputation Mode — automatically re-queries every brand paired with a configurable list of risk terms (temu scam, robinhood lawsuit, paypal fraud…) to surface completions a bare-brand query would miss. No Google account, login, or API key is required; the endpoint is public.

What makes this different from a plain autocomplete scraper is the classification layer on top: every returned suggestion is scanned against your risk-term list and flagged (hasNegative, negativeSuggestions, topNegativeCompletion), and — because the Actor calls Google's client=chrome suggest variant instead of the more common firefox one — every suggestion also carries Google's own prominence score and type classification, which most autocomplete scrapers don't expose at all.

Real capabilities, read from the input schema and source:

• 🛡️ Negative-probe expansion — automatically pairs each brand with every risk term (negativeTerms) to surface damaging completions a bare-brand query wouldn't return
• 🔎 Deterministic risk-term flagging — every suggestion Google returns, from any query, is scanned for a risk-term match and marked
• 📊 Google's own relevance & type score — google:suggestrelevance and google:suggesttype (QUERY vs NAVIGATION) per suggestion, plus the seed's verbatimRelevance
• ⚡ Plain autocomplete mode — turn Reputation Mode off and it behaves as an A–Z prefix/suffix keyword-expansion scraper instead
• 🌐 77 suggestion languages, 69 target countries — selectable per run, mapped to Google's hl/gl parameters
• 🔒 Self-healing proxy — falls back none → Google-SERP datacenter → residential automatically when a request gets blocked

What data can you get with Google Search Autocomplete Scraper With Negative Suggestions?

Every run returns four kinds of data in a single flat row per query: the raw suggestion list, a negative-suggestion flag set, Google's own relevance/type metadata, and a query/run record for auditing.

Result Type	Extracted Fields	Primary Use Case
Autocomplete suggestion	suggestion_01 … suggestion_NN, suggestions, suggestionCount	Keyword research, UX/search-box research, tracking what Google actually shows
Negative-suggestion flag	hasNegative, negativeCount, negativeSuggestions, matchedNegativeWords, topNegativeCompletion, topNegativeRelevance	Brand-reputation monitoring, PR crisis-signal detection
Relevance & type metadata	relevance_01 … relevance_NN, type_01 … type_NN, verbatimRelevance	Prioritizing which suggestion Google itself treats as most prominent
Query / run record	query, brand, expansionType, modifier, blocked	Audit trail, pipeline filtering, debugging a specific query

Negative-suggestion detection

This is the capability none of the comparable autocomplete Actors on the Apify Store expose: a built-in classifier that turns raw completions into a reputation signal instead of leaving you to eyeball a suggestion list. It works two ways at once. First, when reputationMode is on (the default), the Actor queries brand + <term> for every entry in negativeTerms — this is what actually surfaces damaging completions, because Google rarely autocompletes "scam" under a bare brand query but frequently confirms it once you start typing the pairing. Second, every suggestion returned from any query — probe or plain — is scanned with word-boundary matching (tolerating plural/verb suffixes like -s, -es, -ed, -ing) against the same term list, and any hit is collected into negativeSuggestions, counted in negativeCount, and the single highest-relevance hit is surfaced as topNegativeCompletion:

{
  "brand": "temu",
  "query": "temu scam",
  "expansionType": "negative_probe",
  "modifier": "scam",
  "hasNegative": true,
  "negativeCount": 2,
  "negativeSuggestions": ["temu scam reddit", "temu scam or legit"],
  "matchedNegativeWords": ["scam"],
  "topNegativeCompletion": "temu scam reddit",
  "topNegativeRelevance": 601
}

Relevance & suggestion-type metadata

Because the Actor queries Google's client=chrome suggest variant instead of the more common firefox one, every response carries a google:suggestrelevance prominence score and a google:suggesttype classification (QUERY for a completed search phrase, NAVIGATION for a completion Google treats as a destination, e.g. a domain-like phrase) that the firefox client simply omits. These land as relevance_01/type_01 through relevance_NN/type_NN, aligned index-for-index with suggestion_01…NN, plus verbatimRelevance for the seed query itself — so you can rank which damaging (or ordinary) completion Google itself considers most prominent, not just that it exists.

Why not build a Google autocomplete monitor yourself?

Google does not publish an official, documented API for search-box autocomplete. The endpoint this Actor (and every browser address bar) calls — suggestqueries.google.com/complete/search — is an internal, undocumented surface: no published terms, no versioning guarantee, no rate-limit documentation, and it can start blocking or reshaping its response at any time without notice. Building a reliable version of this yourself means reverse-engineering that response format, handling client=chrome's metadata array structure (the relevance/type block ships as the last dict element of the response, not a named field), building a country/language mapping across dozens of markets, and standing up a proxy escalation path for when Google starts blocking your IP mid-run.

None of that is where the actual work is, though — the actual work is deciding what counts as a "damaging" completion and re-querying at the right pairings to surface it, which is the negative-probe logic and the 16-term default risk list this Actor ships with. If you only need one suggestion list for one query once, curling the endpoint yourself is fine. If you need it repeatable, localized, resilient to blocks, and pre-classified for reputation risk, that's what this Actor replaces.

Maintaining an accurate language/country code table by hand is also easy to get subtly wrong — a mismatched two-letter code sends Google a value it doesn't recognize for that parameter, and you get results localized differently than you intended with no error thrown. This Actor's own table isn't immune to that class of mistake either: see the country: "United Kingdom" caveat flagged in the Input section below. The point isn't that a maintained table is bug-free, it's that a bug in a mapping table you can read and verify is a much smaller problem than reverse-engineering the mapping from scratch.

What's the difference between keyword-research tools and autocomplete reputation monitoring?

Keyword-research tools (Google Keyword Planner, Ahrefs, SEMrush-style tools) report historical search volume for terms you already know to look up — they tell you how often "temu scam" was searched last month. Autocomplete reputation monitoring tells you what Google is suggesting right now as someone starts typing your brand name — a live signal, not a lagging one, and one that shows up in autocomplete before it shows up in a monthly volume report.

That distinction matters because reputation risk doesn't wait for a reporting cycle. A lawsuit filing, a viral complaint thread, or a recall notice can start shifting autocomplete completions within the news cycle that follows it, long before enough people have searched the pairing for it to register as meaningful "volume" anywhere. Keyword-volume tools were built to answer "what should I write content about," not "is Google currently surfacing something damaging about my brand" — they don't classify results by risk at all, because that was never their job.

Google Search Autocomplete Scraper With Negative Suggestions returns both categories of data in the same row: the plain completion list (suggestion_01…NN) any autocomplete scraper returns, and the reputation classification layer (hasNegative, negativeSuggestions, topNegativeCompletion) layered on top of it — so you don't need a separate keyword tool and a separate brand-monitoring subscription to get both signals.

How to scrape Google autocomplete for brand-reputation signals

1. Open Google Search Autocomplete Scraper With Negative Suggestions on the Apify Store and click Try for free (or Run if you already have it saved).
2. Enter the brands, products, or names you want to watch in queries — one per line (the input ships prefilled with temu, robinhood, paypal as examples).
3. Set the real query controls: language and country to localize suggestions to a market, and decide whether reputationMode stays on (probes negativeTerms) or off (switches to the usePrefix/useSuffix A-Z expansion instead).
4. Start the run from the Apify Console, or trigger it via the Apify API with your token.
5. Download the results as JSON, CSV, or Excel from the dataset, or pull them programmatically via the API once the run finishes.

How to run multiple brands and risk terms in one job

queries accepts an array, so a single run covers every brand you list — each is expanded and queried independently, tagged back to its brand in the output row. In Reputation Mode, every brand is crossed with every entry in negativeTerms, so N brands against the built-in 16-term list produce N × 17 rows (the bare brand seed plus 16 negative probes) from one run; supplying your own shorter or longer negativeTerms list changes that multiplier directly. Expanded queries are processed one at a time, in the order shown in the run log — there is no parallel fan-out across queries in this Actor, so total run time scales with how many brands and risk terms you queue up, not with how fast any single request completes.

⬇️ Input

Configure the input under ⬇️ Input on the Actor's page, or pass the same keys as JSON via the API. queries is the only required field.

Parameter	Required	Type	Description	Example Value
queries	Yes	array of strings (editor: stringList)	Brand names, products, or people to watch — one per line. Each is probed against your risk terms.	["PayPal", "Temu", "Robinhood"]
reputationMode	No	boolean, default true	ON: query each brand as-is plus one negative-probe per risk term (e.g. temu scam, temu lawsuit) to surface damaging autocompletes — no A-Z volume blow-up. OFF: behaves like a plain autocomplete scraper, using the A-Z expansion toggles below.	true
negativeTerms	No	array of strings (editor: stringList)	Words that mark a completion as damaging. Used both to probe (brand + term) and to flag returned suggestions. Leave empty to use the built-in list: scam, complaints, fraud, lawsuit, ripoff, problems, fake, scandal, sucks, dangerous, recall, refund, not working, down, reviews, vs.	["scam", "lawsuit", "complaints"]
includeRelevance	No	boolean, default true	Adds Google's own prominence score (relevance_NN) and QUERY vs NAVIGATION classification (type_NN) for every suggestion, plus the seed's verbatimRelevance.	true
language	No	string, enum of 77 language names, default "English"	Language of the autocomplete suggestions (maps to Google's hl parameter).	"English"
country	No	string, enum of 69 country names, default "United States"	Country Google localizes suggestions for (maps to Google's gl parameter). Reputation issues often differ by market.	"United States"
usePrefix	No	boolean, default false	Only used when Reputation Mode is OFF. Adds a-z before each keyword (e.g. a temu, b temu) for broader long-tail discovery.	false
useSuffix	No	boolean, default false	Only used when Reputation Mode is OFF. Adds a-z after each keyword (e.g. temu a, temu b).	false
proxyConfiguration	No	object (editor: proxy), prefilled {"useApifyProxy": true}	Optional proxy configuration. The Actor falls back automatically: no proxy → Apify's GOOGLE_SERP datacenter group → residential, escalating only when a request gets blocked.	{"useApifyProxy": true}

Example JSON input:

{
  "queries": ["temu", "robinhood", "paypal"],
  "reputationMode": true,
  "negativeTerms": ["scam", "lawsuit", "complaints", "fraud", "reviews"],
  "includeRelevance": true,
  "language": "English",
  "country": "United States",
  "usePrefix": false,
  "useSuffix": false,
  "proxyConfiguration": { "useApifyProxy": true }
}

⚠️ Common pitfalls, read from the source:

• usePrefix/useSuffix do nothing while reputationMode is on (the default). They only take effect once you switch Reputation Mode off — leaving Reputation Mode on and toggling either A-Z switch produces no visible change in the query set. Turning Reputation Mode off does not disable negative-term flagging either — hasNegative/negativeCount/etc. still get computed against your negativeTerms list in plain mode; it just stops the extra brand+term probe queries.
• Selecting "United Kingdom" as country sends gl=uk to Google, not gl=gb. The Actor's internal country-code map has "United Kingdom": "uk", but uk is not the ISO 3166-1 alpha-2 code Google's gl parameter expects — that's gb (uk is Ukraine's IANA ccTLD, not a country code). If you're localizing specifically for the UK market, verify your results, since Google may not localize as expected for that value.

⬆️ Output

Results are pushed to the run's default dataset as one flat JSON object per query, exportable as JSON, CSV, Excel/XLSX, or HTML table directly from the Apify Console, or retrievable via the Apify API/apify_client. The dataset's default view (titled "Reputation & suggestions," inside the dataset labeled "🛡️ Brand Reputation Report") surfaces 15 columns for quick scanning — brand, query, expansionType, hasNegative, negativeCount, topNegativeCompletion, topNegativeRelevance, suggestionCount, suggestion_01, relevance_01, type_01, suggestion_02, relevance_02, suggestion_03, relevance_03 — but that's a curated subset. Every row actually carries more: the full suggestions array, negativeSuggestions, matchedNegativeWords, verbatimRelevance, modifier, and blocked, plus relevance_NN/type_NN/suggestion_NN columns beyond index 3 when Google returns more completions. Pull the full row via the Export dropdown's "all fields" option, or the API, to get everything below.

Scraped results

[
  {
    "query": "temu",
    "suggestion_01": "temu app",
    "suggestion_02": "temu shopping",
    "suggestion_03": "temu scam",
    "relevance_01": 851,
    "type_01": "NAVIGATION",
    "relevance_02": 812,
    "type_02": "QUERY",
    "relevance_03": 604,
    "type_03": "QUERY",
    "verbatimRelevance": 1300,
    "brand": "temu",
    "expansionType": "brand_seed",
    "modifier": null,
    "suggestions": ["temu app", "temu shopping", "temu scam"],
    "suggestionCount": 3,
    "hasNegative": true,
    "negativeCount": 1,
    "negativeSuggestions": ["temu scam"],
    "matchedNegativeWords": ["scam"],
    "topNegativeCompletion": "temu scam",
    "topNegativeRelevance": 604,
    "blocked": false
  },
  {
    "query": "temu scam",
    "suggestion_01": "temu scam reddit",
    "suggestion_02": "temu scam or legit",
    "relevance_01": 601,
    "type_01": "QUERY",
    "relevance_02": 590,
    "type_02": "QUERY",
    "verbatimRelevance": 700,
    "brand": "temu",
    "expansionType": "negative_probe",
    "modifier": "scam",
    "suggestions": ["temu scam reddit", "temu scam or legit"],
    "suggestionCount": 2,
    "hasNegative": true,
    "negativeCount": 2,
    "negativeSuggestions": ["temu scam reddit", "temu scam or legit"],
    "matchedNegativeWords": ["scam"],
    "topNegativeCompletion": "temu scam reddit",
    "topNegativeRelevance": 601,
    "blocked": false
  },
  {
    "query": "temu lawsuit",
    "suggestion_01": "temu lawsuit 2026",
    "relevance_01": 550,
    "type_01": "QUERY",
    "verbatimRelevance": 700,
    "brand": "temu",
    "expansionType": "negative_probe",
    "modifier": "lawsuit",
    "suggestions": ["temu lawsuit 2026"],
    "suggestionCount": 1,
    "hasNegative": true,
    "negativeCount": 1,
    "negativeSuggestions": ["temu lawsuit 2026"],
    "matchedNegativeWords": ["lawsuit"],
    "topNegativeCompletion": "temu lawsuit 2026",
    "topNegativeRelevance": 550,
    "blocked": false
  }
]

Billing note, read from the source: every row the Actor pushes is charged under the row_result event — including rows where a query got blocked after retries and returned no suggestions at all (blocked: true, suggestionCount: 0, hasNegative: false). There is no separate, uncharged error row; the Actor does not filter blocked attempts out of billing. If you want to exclude them from your own analysis after export, filter on blocked == false, or equivalently suggestionCount > 0.

Plain-mode output shape: with reputationMode off, rows come from the A-Z expansion instead of the brand/risk-term probes, so a few fields read differently. expansionType becomes seed (the bare keyword) or alphabet (an A-Z prefix/suffix variant) instead of brand_seed/negative_probe; modifier becomes the single letter that generated that row (or null for the seed) instead of a risk term; and brand is always null, since the brand-linking logic only runs in Reputation Mode. hasNegative/negativeCount/negativeSuggestions still compute against negativeTerms on whatever suggestions come back — for example:

{
  "query": "a temu",
  "suggestion_01": "a temu account",
  "suggestion_02": "a temu shop",
  "relevance_01": 700,
  "type_01": "QUERY",
  "relevance_02": 650,
  "type_02": "QUERY",
  "verbatimRelevance": null,
  "brand": null,
  "expansionType": "alphabet",
  "modifier": "a",
  "suggestions": ["a temu account", "a temu shop"],
  "suggestionCount": 2,
  "hasNegative": false,
  "negativeCount": 0,
  "negativeSuggestions": [],
  "matchedNegativeWords": [],
  "topNegativeCompletion": null,
  "topNegativeRelevance": null,
  "blocked": false
}

How can I use the data extracted with Google Search Autocomplete Scraper With Negative Suggestions?

• 🛡️ Brand and reputation teams: schedule a weekly run across your brand list, filter the dataset on hasNegative == true, and route any row with a new topNegativeCompletion to Slack or email before it escalates.
• 🤖 AI engineers and LLM developers: call the Actor as a grounding step — pass a brand name in, get back suggestions and negativeSuggestions as live context, and let the model reason over what Google is currently showing instead of stale training data.
• 📊 Market and competitive researchers: run your brand alongside competitor names with the same negativeTerms list, then compare negativeCount and topNegativeRelevance across brands to see whose reputation signal is stronger in autocomplete right now.
• ✍️ SEO and content teams: switch reputationMode off, turn on usePrefix/useSuffix, and use the plain suggestion_NN completions for long-tail keyword and content-gap research, independent of the reputation layer.

🎯 How do you monitor negative suggestions over time?

Reputation monitoring is a diffing exercise, not a one-off lookup: what matters isn't a single run's negativeSuggestions list, it's whether that list changes between runs, and how fast. Autocomplete shifts as search behavior shifts, so a new entry in negativeSuggestions, a rising topNegativeRelevance, or a matchedNegativeWords value you haven't seen before on a given brand is the actual signal — a bare hasNegative: true that stays constant week to week is comparatively low urgency next to one that just turned true for the first time.

The fields worth diffing between runs are hasNegative, negativeCount, topNegativeCompletion, topNegativeRelevance, and matchedNegativeWords, keyed by brand and modifier so you're comparing the same brand+risk-term pairing run over run. A practical loop: save your brand list and negativeTerms as an Apify task, attach a schedule to it (for example, daily at a fixed hour) from the Actor's Actions → Schedule menu, then after each run, pull the new dataset via the API and diff it against the previous run's export on brand + modifier — alert when topNegativeRelevance rises or a brand's hasNegative flips from false to true. The Actor itself doesn't store or diff prior runs — that comparison happens in your own script, spreadsheet, or database once you're pulling scheduled exports.

Integrate Google Search Autocomplete Scraper With Negative Suggestions and automate your workflow

Google Search Autocomplete Scraper With Negative Suggestions works with any language or tool that can send an HTTP request through the Apify API.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<YOUR_USERNAME>/google-search-autocomplete-scraper-with-negative-suggestions").call(
    run_input={
        "queries": ["temu", "robinhood", "paypal"],
        "reputationMode": True,
        "language": "English",
        "country": "United States",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("hasNegative"):
        print(item["brand"], "->", item["topNegativeCompletion"], item["topNegativeRelevance"])

Scheduled monitoring and delivery

Save your brand list and risk terms as an Apify task, then attach a schedule from the Actor's Actions → Schedule menu — cron strings like 0 7 * * * (daily at 7 AM) work directly. For push delivery on completion, attach an Apify webhook on the ACTOR.RUN.SUCCEEDED event to notify your own endpoint, or pull the dataset on your own polling interval via the API.

Is it legal to scrape Google's autocomplete results?

Yes — scraping publicly accessible autocomplete suggestions is generally lawful, and this Actor returns only what any visitor typing into Google's search box sees. Autocomplete completions aren't personal data about a private individual in the way a social-profile scrape would be (unless you deliberately query a private person's full name, in which case you're subject to that jurisdiction's personal-data rules); for the brand/product/keyword monitoring this Actor is built for, the relevant framework is Google's own Terms of Service, not GDPR or CCPA. Scraping for operational brand monitoring and scraping to train an AI model carry different risk profiles and different terms considerations — treat them separately. Consult your legal team for commercial use cases involving bulk data storage or redistribution of scraped results.

Frequently asked questions

Can I localize suggestions by language and country?

Yes. language (77 options, maps to Google's hl parameter) and country (69 options, maps to gl) control localization independently — you can request Spanish-language suggestions localized to Mexico, for example. One caveat: selecting country: "United Kingdom" currently sends gl=uk rather than the correct ISO code gb, so UK-specific localization may not behave as expected until that mapping is corrected — see the Input section above.

What's the difference between Reputation Mode and plain autocomplete mode?

reputationMode (default true) probes each brand against every entry in negativeTerms to surface damaging completions directly. Turning it off switches to a plain autocomplete scraper: it drops the negative-probe queries and instead lets usePrefix/useSuffix add A-Z letters before or after each keyword for broad long-tail discovery. Negative-term flagging (hasNegative, negativeCount) still runs on whatever suggestions come back either way.

How does the Actor handle Google blocking or rate-limiting?

Each query starts with no proxy at all. If Google returns a 403/429/503, an empty response, or invalid JSON, the Actor escalates: first to Apify's GOOGLE_SERP datacenter proxy group, then — if still blocked — to residential proxies (your own proxyConfiguration if it sets useApifyProxy, otherwise Apify's RESIDENTIAL group by default). Once escalated to residential, it stays there for the rest of the run and retries a blocked query up to 3 times, waiting 1, 2, then 3 seconds between attempts, before giving up on that specific query and marking the row blocked: true. Each individual request also carries a fixed 30-second total timeout (10-second connect timeout) — a request that hangs past that window is treated the same as a failed one and follows the same escalation path.

Does negativeTerms support multi-word phrases?

Yes. A single-word term like scam matches on token boundaries (tolerating common suffixes, so scams, scammed, and scamming all match scam), while a multi-word term like not working matches as a substring against the full suggestion text instead. That's why the built-in default list mixes both — most entries are single risk words, but not working is deliberately phrased as a phrase so it doesn't require an exact token match.

Does it extract negative suggestions?

Yes — every suggestion returned from any query is scanned against negativeTerms (your list, or the built-in 16-term default) using word-boundary matching that tolerates common plural/verb suffixes. Matches land in negativeSuggestions, are counted in negativeCount, and the single most prominent (highest-relevance) match is surfaced separately as topNegativeCompletion/topNegativeRelevance. A row can have hasNegative: false if no suggestion for that specific query matched any term — this is expected and doesn't mean the brand has no risk terms elsewhere in the result set.

How many suggestions does it return per query?

Whatever Google's client=chrome suggest endpoint returns for that exact query — the Actor does not cap or truncate the list. suggestionCount on each row tells you exactly how many landed in that row's suggestion_01…NN columns, and it varies query to query and market to market.

How do I monitor a brand's reputation in autocomplete over time?

Save your brand list and negativeTerms as an Apify task, attach a schedule so it runs on a fixed cadence, then after each run compare the new dataset against the previous one on brand + modifier, watching hasNegative, topNegativeCompletion, and topNegativeRelevance for changes. See "How do you monitor negative suggestions over time?" above for the full loop.

Does it work with Claude, ChatGPT, and AI agent frameworks?

It's not documented as reachable through Apify's MCP server. It is callable as a standard HTTP endpoint through the Apify API by any agent framework or script that can make a request and parse JSON — an agent can trigger a run, poll or await it, and pass the resulting suggestions/negativeSuggestions back into its context as grounding for a brand-reputation question.

How does it compare to other Google autocomplete scrapers?

As observed on the Apify Store on 2026-07-26: maged120/google-autocomplete-ppe returns text/subtitle/thumbnail/url per suggestion with language/country code lookups, but no relevance scoring and no reputation classification. johnvc/google-autocomplete-api returns a flat query/position/value per suggestion and bills per suggestion returned (its listing advertises $0.002 per suggestion, checked 2026-07-26 — not measured here), but again has no relevance metadata and no negative-term detection. scraper-mind/google-search-autocomplete-api returns plain suggestion_NN columns with no relevance or type data either. None of the three probe brand+risk-term pairings or flag damaging completions — that classification layer, plus Google's own relevance/type metadata via the chrome client, is what this Actor adds on top of the same base autocomplete data.

Can I use it without managing proxies or platform credentials?

Yes. No Google account, login, or API key is required — the suggest endpoint is public. Proxy handling is automatic: the Actor starts with no proxy and escalates through Apify's own datacenter and residential proxy groups only if Google starts blocking requests, using the proxyConfiguration input if you provide one, or Apify defaults if you don't.

💬 Your feedback

Found a bug, a suggestion field that looks off, or a market where localization isn't matching what Google actually shows? Let us know through the Actor's Issues tab on its Apify Store page, or message Scrapier directly through the Apify Console — reports like the country-code mapping noted above are exactly what get fixed fastest when flagged.