Does Your Product Work in São Paulo? A Geo-Testing Lab Notebook, With Providers Compared

Teams ship localized products from a laptop in a headquarters timezone and discover localization in production — prices in the wrong currency, streaming licenses “unavailable in your region,” app-store listings invisible, ad creatives never delivering. The missing discipline isn’t more QA; it’s a lab notebook of repeatable geo-protocols run from real residential connectivity in each market. This is the notebook, tested twice against two providers: Thordata and Decodo.

The Problem This Notebook Exists For

Geo-dependent behavior is everywhere in a digital product, and none of it is testable from the office:

• Storefront truth: localized pricing, currency strings, tax-inclusive display, payment methods — all served by IP geography.
• Catalog visibility: app-store ranking by country, availability flags, regional search listings.
• Media licensing: the “not available in your region” wall, which is a routing rule, not a bug.
• Ad delivery: what creative actually serves in-market (see the SERP monitoring solution for the search-placement half of this).
• Regulatory surfaces: consent banners, disclosure order, and the language-of-record decisions that vary market to market.

Every one of these is a configuration the office never sees. The test: run them from the market, periodically, with structure.

The Protocols

Four repeatable tests. Each one specifies what success looks like and what the traffic costs, because geo-testing dies when it’s expensive per run.

Protocol 1: Market parity sweep. Hit N product endpoints from each target market, assert every field (currency, price, payment methods) against the expected matrix. Automate with residential proxies pinned per market:

import requests

# Endpoints generated from the dashboard (Thordata ships an endpoint
# generator; Decodo provides equivalent geo-pinned endpoints per zone)
def parity_probe(market: str, proxy: str, url: str):
    r = requests.get(url, proxies={"http": proxy}, timeout=30)
    page = parse(r.text)
    return {
        "market": market,
        "status": r.status_code,
        "currency_seen": page.currency,          # BRL expected in São Paulo
        "price_seen": page.price,
        "methods_seen": page.payment_methods,
    }

results = [parity_probe(m, endp, PRODUCT_URL)
           for m, endp in MARKETS_AND_PROXIES.items()]
diff_against_expectation(results, EXPECTATION_MATRIX)  # your source of truth

Protocol 2: Session-dependent flows. Checkout and login differ from anonymous browsing; they need the same IP for minutes. Sticky sessions — up to 30–90 minutes on Thordata’s residential pool — turn a checkout test into one session instead of a retry lottery.

Protocol 3: Store and search visibility. Rank checks are SERP collection with geo fidelity. Structured per-response collection (Thordata’s SERP API from roughly $0.70 per 1,000 responses at volume) beats HTML traffic (per-GB) for this protocol by a wide margin — and run the continuous SERP data crawling service when the job is scheduled trend tracking rather than on-demand checks.

Protocol 4: The license wall. Media-availability testing: run the content-URL matrix per market, classify “plays / region-blocked / errored,” alert on drift. Cheap, and the only way to know whether your “available in 12 markets” page is a claim or a fact.

The Providers, Compared Honestly

Both companies are credible residential providers. For geo-testing workloads specifically, here’s what published pricing and documented capabilities show:

Where Decodo is the better fit: the lighter and less frequent the testing. A 3-day trial and a 100 MB allowance cover a proof-of-concept run without any account setup conversation; a polished dashboard suits QA engineers who want to click, not configure; and if your monthly testing volume lives under ~10 GB, the tier math barely diverges. Decodo’s site-unblocker product (from $0.95/1,000) also covers the stubborn-target corner case cleanly.

Where Thordata is the better fit: the notebook above becomes a program. Weekly parity sweeps on 150 endpoints × 12 markets eat traffic fast; at scale the published slider ($2.00/GB falling to $0.65/GB) makes continuous geo-testing budget-line real instead of aspirational, and ASN targeting matters for Protocol 3 in markets where a city label alone doesn’t reliably reproduce the real user’s network path. One platform covering proxy, scraper-API, SERP, and datasets also means the visibility checks and the parity checks land in one dashboard and one invoice.

Neither is “the better provider.” They are better fit for different testing tempos — and the table above is enough to pick yours.

Making the Notebook Self-Sustaining

Three practices keep a geo-testing program from becoming abandonware:

1. Run the protocols on a schedule, not on release. A parity sweep at release time catches what changed; one at release time *and* weekly catches what changed in your absence — market configs are remote state you don’t deploy.
2. Keep every probe’s output joinable. Market, endpoint, expected, observed, timestamp. Six columns; without them, next quarter’s engineer re-investigates from zero.
3. Price the program before it starts. A weekly 12-market sweep costs a few dollars in per-response SERP pricing plus modest slider-priced traffic for the storefront probes. The number is small enough that skipping the discipline is now a choice, not a constraint. That was never true at old per-GB rates, which is the honest explanation for why geo-testing programs exist now and mostly didn’t before.

FAQ

Can we run Protocol 1 on datacenter proxies for cost?
Sometimes — but the failure mode is brutal: datacenter traffic changes the answers (blocked, region-inferred, simplified pages), and your green test results become fiction. The residential pool exists precisely because the markets you test are defined by real network paths.

How many markets before this gets expensive?
The arithmetic that matters: at ~150 endpoints × 12 markets × weekly, Protocol 1 lands in the low tens of GB per month; the slider puts that near $50–150/month, and Protocol 3’s per-response pricing costs a few dollars. The program is cheap at twelve markets and stays roughly linear to fifty.

Does the same infrastructure cover market-research probes (pricing of competitors in-market)?
Yes — the scraper-API layer (from ~$0.50/1,000 structured results) covers the major commercial platforms; search-placement monitoring covers their visibility. The QA notebook and the competitor notebook share one stack.

We test mobile apps, not web. Same idea?
Yes: route device emulators and API clients through the residential endpoint per market, and your app’s geo-dependent surfaces behave as they will for users. App-store ranking itself is Protocol 3 data.

The First Entry

Start the notebook with one protocol: pick your highest-stakes market, run Protocol 1 against your top 20 endpoints, and write down what actually renders. In every product I’ve watched do this, at least one field disagrees with the expectation matrix on day one — currency strings, payment icons, or an availability flag quietly flipped by a market rollout nobody remembered. The geo-test exists because remote configuration is real configuration; the lab notebook is how your QA practice admits it. If you want the whole program running by next sprint, both vendors’ trials let you validate all four protocols at zero spend first — the rest is scheduling and the expectation matrix only you can write.