How to Search Google From Another Country

On 15 April 2025 Google published an update on its country code top-level domains. It said that since 2017 it has given everyone "the same experience with local results" regardless of which domain they typed, and that it "will begin redirecting traffic from these ccTLDs to google.com." The same post warns that you "may be prompted to re-enter some of your Search preferences."

We checked the rollout on 30 October 2026 with plain HTTP requests. Every country domain we tried answered with a 301 to the same place:

So the domain is no longer a location control. What's left is what Google's "Manage your location" help page lists as its inputs: your device location, a home or work address saved in your account, your past activity, and your connection's IP address, which Google admits maps to location only roughly. Of those four, only the IP is something you can swap cleanly from outside the country, and that's why two of the three methods below involve a proxy.

Fidelity here means one thing: how close the page you capture is to what a logged-out person sitting in that country would see.

Methods 2 and 3 reach similar fidelity. The difference is that a script can repeat the same capture across five countries in a minute and check its own output, which a person clicking through tabs won't do reliably.

Two parameters do the work, and Google describes both on the cse.list page of its Programmable Search developer docs. For gl, the docs say it "boosts search results whose country of origin matches the parameter value." For hl, the job is the interface language. Those definitions are written for the API, but the same parameter names are accepted on the normal results URL:

https://www.google.com/search?q=versicherung+vergleich&gl=de&hl=de
https://www.google.com/search?q=seguro+auto&gl=br&hl=pt-BR

Read the API wording carefully. gl boosts results from a country; it doesn't make Google believe you are in that country. Your IP still says where you are. In practice you get a hybrid page: interface in German, some German sites lifted, but local packs, ads and anything location-sensitive still keyed to your real network.

There's also a settings route. Google's Search settings page (google.com/preferences, checked 30 October 2026) has a "Language and region" section. It changes preferences tied to your browser or account, not your network, so it sits at the same fidelity as the parameters.

We tried Method 1 from our office connection in Bengaluru (an Indian residential ISP) using headless Chromium on 30 October 2026, with gl=de&hl=de, then gl=br&hl=pt-BR, then gl=jp&hl=ja. All three requests were redirected to Google's /sorry/index challenge page. Two details from that small test matter later:

• The challenge page came back in the language set by hl: German, Portuguese and Japanese respectively. A check that looks only for English block text would have missed all three.
• The final response our browser recorded for the Japanese attempt was HTTP 200. Status codes alone won't tell you that you were blocked.

Three requests from one IP isn't a block rate, and a headless browser is not a typical visitor. Treat it as a demonstration of what a failure looks like, not a measurement of how often it happens.

This is the right method when a person needs to look at the page: reviewing ad copy in Brazil, taking screenshots for a German client, or reading a local SERP feature by eye. Change the IP, then remove every other signal that points home.

Use a separate browser profile so your main cookies and Google account never touch the session. Chrome takes a proxy on the command line; the Chromium network settings document gives the form --proxy-server="foopy:8080":

:: Windows example: a throwaway profile, a German exit, German UI language
"C:\Program Files\Google\Chrome\Application\chrome.exe" ^
  --user-data-dir="C:\chrome-geo\de" ^
  --proxy-server="http://gateway.sparkproxy.io:11002" ^
  --lang=de ^
  "https://www.google.com/search?q=versicherung+vergleich&gl=de&hl=de"

Chrome will prompt for the proxy username and password, or you can whitelist your IP in the SparkProxy dashboard and skip the prompt. Full Chrome and Firefox setup, including the authentication popup and PAC files, is in our guide to configuring a proxy in Chrome and Firefox, so we won't repeat it. SparkProxy's browser extension is the no-flags alternative; the homepage pitches it as a way to "Switch countries without leaving your tab."

Country selection on the gateway is done in the username. The Premium IPs sample on sparkproxy.io shows the pattern user-country-us, where user is your username and the suffix is the ISO country code, so a German exit is user-country-de and Brazil is user-country-br. Confirm the exact format in your dashboard before you script it. For the background on how a provider maps an IP to a country, and how far to trust that mapping, see what geo-targeting means in proxies.

Port 11002 in the example is Sticky Sessions, which keeps one exit for 5 minutes. For a person paging through results, that matters: page 2 arriving from a different IP than page 1 looks like a different visitor. Our explainer on sticky session proxies covers the trade-offs.

Before you trust the first page, run this short list in the proxied window:

1. Open an IP lookup and confirm the country.
2. Stay signed out of Google.
3. Accept or reject the consent banner the way a local visitor would, because the EU consent screen is itself part of the German experience.
4. Search, then scroll to the footer and read the location line.

When you need the same capture repeated, by country, on a schedule, script it. There are two ways to do that with SparkProxy.

The Scraping API. You pass the Google URL to https://scrape.sparkproxy.io/api/v1, authenticate with an X-API-Key request header, and add country_code. Rendering matters here more than on most targets. On 30 October 2026 we sent a plain HTTP request for a German results URL and got HTTP 200 with about 94 KB of markup and no results at all: a JavaScript stub, rendered in German, saying roughly "click here if you are not redirected in a few seconds." The API's default render_js=true (5 credits) is what gets you a real page; render_js=false (1 credit) gets you the stub.

curl -sG "https://scrape.sparkproxy.io/api/v1" \
  -H "X-API-Key: $SPARKPROXY_API_KEY" \
  --data-urlencode "url=https://www.google.com/search?q=seguro+auto&gl=br&hl=pt-BR" \
  --data-urlencode "country_code=BR" \
  --data-urlencode "json_response=true" \
  -o br.json

Setting json_response=true wraps the result in an envelope whose fields include the upstream status, the credits charged and a body field. That body is Base64-encoded, so every marker check below runs on the decoded string, never the raw field. One trap: format=json does not produce this envelope. The format parameter is a content converter, nothing more.

import base64
import os

import requests

API = "https://scrape.sparkproxy.io/api/v1"


def fetch_serp(google_url, country):
    resp = requests.get(
        API,
        params={"url": google_url, "country_code": country, "json_response": "true"},
        headers={"X-API-Key": os.environ["SPARKPROXY_API_KEY"]},
        timeout=120,
    )
    resp.raise_for_status()
    env = resp.json()
    html = base64.b64decode(env["body"]).decode("utf-8", errors="replace")
    return env["status_code"], env["credits_used"], html

Your own browser through the gateway. If you already run Playwright, point it at the gateway and pass the country in the username. Playwright's docs show the proxy set at launch with server, username and password, or per context:

import os

from playwright.sync_api import sync_playwright

USER = os.environ["SPARKPROXY_USER"]
PASSWORD = os.environ["SPARKPROXY_PASS"]


def capture(google_url, country, locale):
    proxy = {
        "server": "http://gateway.sparkproxy.io:11000",
        "username": f"{USER}-country-{country.lower()}",
        "password": PASSWORD,
    }
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(proxy=proxy, locale=locale)
        page = context.new_page()
        page.goto(google_url, wait_until="domcontentloaded", timeout=60000)
        page.wait_for_timeout(2500)
        html, final_url = page.content(), page.url
        browser.close()
    return final_url, html

The API route is less code and gives you a credit count per capture. The gateway route costs a flat plan instead of credits but makes you own the browsers, their memory, and their fingerprints.

A capture that looks like a results page can still be wrong in two ways: it's a challenge page, or it's a real page for the wrong place. Check both, in this order, cheapest first.

Checks 1 and 2 come straight from our own test pages: the German, Portuguese and Japanese challenge pages all lived at /sorry/index, and the Japanese one we saved contains both captcha-form and g-recaptcha. Matching on those beats matching on English sentences, which change with hl.

Check 4 relies on Google's help page, which says each results page ends with a line naming the location Google used and where that guess came from. Check 5 is our own heuristic, not a Google signal: count how many organic results sit on the target country's domain suffix. It's noisy for global brands, which is why it's a hint and not a verdict.

import re
from html.parser import HTMLParser
from urllib.parse import urlparse

BLOCK_MARKERS = ("/sorry/index", "captcha-form", "g-recaptcha")
LOCAL_SUFFIX = {"DE": ".de", "BR": ".br", "FR": ".fr", "JP": ".jp", "US": ".com"}
COUNTRY_WORDS = {
    "DE": ("Deutschland",), "BR": ("Brasil",), "FR": ("France",),
    "JP": ("日本",), "US": ("United States",),
}


class OrganicHosts(HTMLParser):
    """Collect hosts of links that wrap an <h3> title, in page order."""

    def __init__(self):
        super().__init__()
        self.hosts, self._href = [], None

    def handle_starttag(self, tag, attrs):
        if tag == "a":
            self._href = dict(attrs).get("href") or ""
        elif tag == "h3" and self._href and self._href.startswith("http"):
            host = urlparse(self._href).netloc.lower()
            if host and "google." not in host and host not in self.hosts:
                self.hosts.append(host)

    def handle_endtag(self, tag):
        if tag == "a":
            self._href = None


def verify(html, country, final_url=""):
    if any(m in final_url or m in html for m in BLOCK_MARKERS):
        return {"verdict": "blocked", "hosts": []}
    parser = OrganicHosts()
    parser.feed(html)
    hosts = parser.hosts[:10]
    if not hosts:  # JS stub, consent screen or a layout the parser no longer reads
        return {"verdict": "empty", "hosts": []}
    text_tail = re.sub(r"<[^>]+>", " ", html)[-25000:]
    footer_ok = any(w in text_tail for w in COUNTRY_WORDS.get(country, ()))
    suffix = LOCAL_SUFFIX.get(country, "")
    local = sum(1 for h in hosts if suffix and h.endswith(suffix))
    verdict = "local" if footer_ok else "unconfirmed"
    return {"verdict": verdict, "hosts": hosts, "local_share": local / max(len(hosts), 1)}

Google changes its markup often, so the