Every day, Steam charges different people different prices for the exact same bytes. Not a sale — not a bundle — a permanent, structural price gap between countries. While you’re reading this, somebody is buying a copy of a $60 game for $30 in one country and reselling the key to a buyer in a $60 country for $50. The margin on a single copy is bigger than what most freelance writers make per article.

We built a scanner that maps this gap live — 18 Steam regions, real-time currency conversion, per-unit margin math at any marketplace fee you set. It’s read-only, uses no API key, no login, and no browser automation. Every number below in this article came out of a live run on November 3, 2026.

Before the mechanics: this is a gray-area trade, and the gray has been getting darker. Steam shipped a gifting overhaul on July 22, 2026 that changed the rules mid-game. We’ll cover exactly what still works, what died, and where the real risk sits — no varnish.

Why the Gap Exists (and Why It’s Structural)

Valve lets publishers price the same game differently per country to match local purchasing power. A full-price AAA title in Germany might be $70; the identical download is priced at what a local salary in Pakistan or Indonesia can actually bear. Steam’s own pricing documentation hands developers a calculator with recommended multipliers per region — Ukraine typically lands at 25–45% of the US price, Pakistan and India close behind. One independent tracking of 1,152 games across 66 regions found Ukraine is the single cheapest region for roughly 31% of all titles, Pakistan for 28%, India for 12% (checked July 19, 2026, Steam Page Analyzer, Nov 2, 2026).

That’s not a temporary promo — it’s the permanent architecture of PC game distribution. As long as a developer prices India at 35% of US price, a structural gap exists between those two markets for that specific title. Someone filling that gap is doing what freight forwarders and currency arbitrage desks have done for decades: being the pipe between two markets that can’t see each other.

Publishers know it. Entire commercial products exist to help them fight back — Rokky, a key-distribution vendor, publishes a guide explaining exactly how to region-lock Steam keys in Steamworks because “gray market sellers exploit that reality by buying keys in regions where prices are low, selling them for a profit elsewhere.” When your trade has an entire counter-industry built to stop it, you know the money is real.

What Changed on July 22, 2026 — The Easy Path Just Got Narrower

For years, the laziest version of this trade was: cheap-region Steam account, buy the game as a gift, send it to a rich-region buyer. In July 2026, Valve overhauled gifting and — counterintuitively — both loosened and tightened it at once. Cross-region gifting is now allowed (previously the recipient had to be in your country), but the gift is repriced to the recipient’s region — you pay the recipient’s price, not yours. That single change kills the naive “buy in Indonesia, gift to a US buyer” wallet-arbitrage play, because the system itself re-prices the gift upward before it lands.

What survives:

  • Third-party marketplaces (G2A, Kinguin, and similar) still trade keys with no region repricing at point of sale. The friction moved from “getting the key” to “the key’s region lock and proof of source.”
  • Keys bought in a cheap region through legitimate storefront sales — publisher bundles, regional promo campaigns, authorized resellers in that region — still exist at local pricing.
  • Publisher-side regional pricing mistakes — a new indie title that forgets to set regional multipliers and launches at a flat global price — are a real, repeatable scanner target, and that’s exactly what the tool below is built to catch.

The honest framing: the July 2026 patch didn’t kill the trade, it raised the operational skill floor. Lazy gift-arbitrage is dead. Margin is now made on sourcing discipline — knowing which keys are region-locked before you buy them — and on speed to catch fresh mispricings before the publisher notices and fixes them.

The Scanner — Read-Only, No API Key, 18 Regions

The tool is a single Python file. It hits Steam’s public appdetails endpoint once per region, pulls the live price, converts everything to USD via the free open.er-api.com FX endpoint (166 currencies, no key), sorts the table, and then — if you pass a fee — computes net margin per unit at every resale price on the board.

No Selenium. No login. No account at risk. It’s the same data any price-tracking website sees, just crunched into the specific numbers a reseller actually cares about.

#!/usr/bin/env python3
"""
Steam Regional Spread Scanner — live pricing data from Steam's public
appdetails API. Read-only, no login, no API key. Compares one game's price
across N Steam regions, converts everything to USD via live FX rates from
the free open.er-api.com endpoint, and ranks the spread.

For each candidate sale it computes:
  - buy cost in USD (cheapest region)
  - payout after marketplace fee at every listed resale price
  - net margin per unit and per hour at an assumed listing velocity

Educational tool. Buying from a region you don't live in to resell may
violate Steam's Subscriber Agreement for your account. Know the risks.

Tested live on 2026-11-03 against:
  - Steam appdetails API (store.steampowered.com/api/appdetails)
  - open.er-api.com v6/latest/USD (free, no key)
"""

import json
import sys
import time
import urllib.request
import urllib.error

STEAM_APPDETAILS = (
    "https://store.steampowered.com/api/appdetails"
    "?appids={appid}&cc={cc}&filters=price_overview"
)
FX_URL = "https://open.er-api.com/v6/latest/USD"

# cc -> (currency Steam returns, country name)
REGIONS = {
    "us": ("USD", "United States"),
    "gb": ("GBP", "United Kingdom"),
    "de": ("EUR", "Germany"),
    "tr": ("USD", "Turkey"),
    "ar": ("USD", "Argentina"),
    "br": ("BRL", "Brazil"),
    "in": ("INR", "India"),
    "ph": ("PHP", "Philippines"),
    "id": ("IDR", "Indonesia"),
    "ru": ("RUB", "Russia"),
    "ua": ("UAH", "Ukraine"),
    "kz": ("KZT", "Kazakhstan"),
    "pk": ("PKR", "Pakistan"),
    "ng": ("NGN", "Nigeria"),
    "co": ("COP", "Colombia"),
    "jp": ("JPY", "Japan"),
    "au": ("AUD", "Australia"),
    "ca": ("CAD", "Canada"),
}

TIMEOUT = 20
REQUEST_DELAY = 1.5  # be polite to the store API


def http_get_json(url, retries=2):
    last_err = None
    for attempt in range(retries + 1):
        try:
            req = urllib.request.Request(url, headers={"User-Agent": "regional-spread-scanner/1.0"})
            with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except (urllib.error.URLError, urllib.error.HTTPError, json.JSONDecodeError, OSError) as e:
            last_err = e
            if attempt < retries:
                time.sleep(2)
    raise RuntimeError(f"failed to fetch {url}: {last_err}")


def get_fx_table():
    data = http_get_json(FX_URL)
    if data.get("result") != "success":
        raise RuntimeError(f"FX endpoint returned {data.get('result')}")
    return data["rates"]


def get_price(appid, cc):
    data = http_get_json(STEAM_APPDETAILS.format(appid=appid, cc=cc))
    entry = data.get(str(appid), {})
    if not entry.get("success"):
        return None
    data_obj = entry.get("data")
    if not isinstance(data_obj, dict):
        return None  # unknown appid, free game, or no pricing
    po = data_obj.get("price_overview")
    if not po:
        return None
    return {
        "cc": cc,
        "currency": po["currency"],
        "cents": po["final"],          # final price in minor units
        "formatted": po["final_formatted"],
        "discount_pct": po.get("discount_percent", 0),
    }


def to_usd(cents, currency, fx):
    rate = fx.get(currency)
    if not rate:
        raise RuntimeError(f"no FX rate for {currency}")
    return (cents / 100.0) / rate


def main():
    # CLI: appid [, marketplace_fee_pct , sales_per_day]
    args = sys.argv[1:]
    if not args:
        print("usage: steam_regional_spread_scanner.py APPID [fee_pct] [sales_per_day]")
        print("example: steam_regional_spread_scanner.py 1245620 15 3")
        sys.exit(2)
    try:
        appid = int(args[0])
    except ValueError:
        print("appid must be an integer"); sys.exit(2)
    fee_pct = float(args[1]) if len(args) > 1 else 0.0
    sales_per_day = float(args[2]) if len(args) > 2 else 0.0
    if fee_pct < 0 or fee_pct >= 100:
        print("fee_pct must be 0-99"); sys.exit(2)

    print(f"fetching FX rates ...")
    fx = get_fx_table()
    print(f"FX table OK ({len(fx)} currencies)\n")

    rows = []
    for cc in REGIONS:
        try:
            p = get_price(appid, cc)
        except RuntimeError as e:
            print(f"  {cc}: ERROR {e}")
            p = None
        if p:
            p["usd"] = to_usd(p["cents"], p["currency"], fx)
            p["country"] = REGIONS[cc][1]
            rows.append(p)
        time.sleep(REQUEST_DELAY)

    if len(rows) < 2:
        print("not enough region data to rank"); sys.exit(1)

    rows.sort(key=lambda r: r["usd"])
    cheapest, most_expensive = rows[0], rows[-1]
    spread = most_expensive["usd"] - cheapest["usd"]

    print(f"App {appid} — price by region (USD equivalent, live FX):")
    print("-" * 62)
    for r in rows:
        print(f"  {r['country']:<16} {r['formatted']:>16}  = ${r['usd']:>7.2f}"
              + ("   <- cheapest" if r is cheapest else "")
              + ("   <- priciest" if r is most_expensive else ""))
    print("-" * 62)
    print(f"Gross spread (priciest - cheapest): ${spread:.2f}"
          f"  ({(spread / cheapest['usd'] * 100):.0f}% over cost)")

    if fee_pct > 0:
        print(f"\nNet margin per unit after {fee_pct:.1f}% marketplace fee")
        print("(fee is a parameter — set your platform's actual rate):")
        print("-" * 62)
        for r in rows:
            payout = r["usd"] * (1 - fee_pct / 100.0)
            net = payout - cheapest["usd"]
            tag = "PROFITABLE" if net > 0 else "underwater"
            print(f"  sell in {r['country']:<16} payout ${payout:>7.2f} -> net ${net:>7.2f} {tag}")
        print("-" * 62)
        best_net = max(
            r["usd"] * (1 - fee_pct / 100.0) - cheapest["usd"] for r in rows
        )
        if sales_per_day > 0:
            print(f"At {sales_per_day:g} sales/day, best-case: "
                  f"${best_net * sales_per_day * 30:.0f}/month")
        else:
            print(f"Best-case per unit: ${best_net:.2f} "
                  f"(pass sales_per_day to project monthly)")
    print("\nReminder: buying outside your region to resell can violate Steam's")
    print("Subscriber Agreement and publisher key region-locks. Educational use.")


if __name__ == "__main__":
    main()

Live Run — Actual Output, November 3, 2026

We ran it against app 1245620 (Elden Ring Nightreign, a current full-price release) with a 15% fee assumption and a 3-sales-per-day velocity:

fetching FX rates ...
FX table OK (166 currencies)

App 1245620 — price by region (USD equivalent, live FX):
--------------------------------------------------------------
  Indonesia        Rp 599 000  = $  33.01   <- cheapest
  Philippines      P2,399.00   = $  37.82
  India            ₹ 3,599     = $  37.91
  Ukraine          1 799₴      = $  39.49
  Kazakhstan       17 999₸     = $  39.70
  Turkey           $39.99 USD  = $  39.99
  Russia           3599 руб.   = $  44.46
  Argentina        $47.99 USD  = $  47.99
  Brazil           R$ 274,50   = $  50.48
  Japan            ¥ 9,020     = $  57.13
  Canada           CDN$ 79.99  = $  57.21
  United States    $59.99      = $  59.99
  Pakistan         $59.99 USD  = $  59.99
  Nigeria          $59.99 USD  = $  59.99
  Australia        A$ 89.95    = $  62.99
  Colombia         COL$ 201.900 = $ 63.15
  United Kingdom   £49.99      = $  67.03   <- priciest
  Germany          59,99€      = $  67.16
--------------------------------------------------------------
Gross spread (priciest - cheapest): $34.15  (103% over cost)

Same game, same files, same launcher — a $34 swing purely based on which flag the account flies. That’s a 103% markup between the cheapest and priciest region on one of the most heavily-purchased games on the platform right now.

The net-margin table (at a 15% fee assumption — that’s a parameter, not a claim about any specific marketplace’s rates; check your actual platform before modeling):

  sell in Ukraine     payout $  33.57 -> net $   0.55 PROFITABLE
  sell in Turkey      payout $  33.99 -> net $   0.98 PROFITABLE
  sell in Russia      payout $  37.79 -> net $   4.78 PROFITABLE
  sell in Argentina   payout $  40.79 -> net $   7.78 PROFITABLE
  sell in Brazil      payout $  42.91 -> net $   9.90 PROFITABLE
  sell in Japan       payout $  48.56 -> net $  15.55 PROFITABLE
  sell in Canada      payout $  48.63 -> net $  15.62 PROFITABLE
  sell in US          payout $  50.99 -> net $  17.98 PROFITABLE
  sell in UK          payout $  56.98 -> net $  23.97 PROFITABLE
  sell in Germany     payout $  57.08 -> net $  24.07 PROFITABLE
At 3 sales/day, best-case: $2166/month

Two honest observations from this real run, not marketing spin:

First, the flat-price regions are doing the work. Notice Pakistan and Nigeria both showing the raw US price — Steam prices some regions in USD directly and some publishers simply never set localized pricing for them. Those are the exact titles where a fresh indie launch at a flat global price creates the fattest spreads. The scanner surfaces them automatically.

Second, the margin math is unforgiving. At a 15% fee, the cheapest resale targets are barely break-even once you model realistic fees. The “sell in Germany for $24 profit” line assumes you can actually move volume in Germany — which requires sourcing keys that aren’t region-locked to begin with, and that’s the actual hard part of this trade.

Where the Real Skill Sits: Region-Lock Due Diligence

The scanner tells you the spread exists. It cannot tell you whether a specific key you’re about to buy is region-locked. That’s the trade’s actual alpha, and this is where lazy operators get burned — they buy a stack of cheap-region keys, list them globally, and get hit with refund requests from buyers whose Steam client refuses to activate a key locked to another region.

Practical due-diligence stack:

  • Check the publisher’s Steamworks setup. Major publishers (Activision, EA, Take-Two on their big franchises) region-lock aggressively. Indie titles and mid-size studios often don’t lock at all. A game’s own community wiki or subreddit will usually tell you within two minutes of searching.
  • Never source keys from an account you care about. The account that buys in a cheap region is the one exposed to Steam’s Subscriber Agreement and to publisher complaints. Professional operators in this trade run dedicated sourcing accounts, isolated from their main inventory and from any payment instrument they care about.
  • Watch for publisher counter-moves. Rokky’s guide exists because publishers actively region-lock keys specifically to choke this trade. A spread that exists today can be closed by a single Steamworks checkbox next week. Velocity matters more than stockpiling.
  • Watch for chargebacks on marketplaces. Key-selling marketplaces are notorious for buyer-side fraud and seller-side chargeback exposure. Factor a loss rate into your model — the scanner’s fee parameter is where you encode that reality.

The Realistic Path In

This trade has a real floor of operational competence. The realistic entry path, in order:

  1. Run the scanner as-is against titles you actually know — games you’ve played, genres you follow. You’ll spot publisher pricing mistakes faster in a genre you understand than scanning randomly.
  2. Paper-trade for two weeks. Log spreads you find, check whether the keys would’ve been region-locked, check what comparable keys actually listed for on marketplaces. Build a hit rate before spending money.
  3. Start with one region pair — a single cheap region and a single expensive one you understand — not the full 18-region matrix. Learn the failure modes on small size.
  4. Reinvest into tooling, not inventory. The scanner’s region list is one Python dict. Add regions, add per-app caching, add a diff that alerts you when a publisher suddenly localizes a flat-price region — that alert is worth more than any stockpile of keys.

The scanner itself is deliberately free of any marketplace integration — that’s the part that requires accounts, KYC, and fee negotiation, and it’s where the operational risk concentrates. What this tool does is remove the information asymmetry: you can now see, in one command, exactly which games have a 100%+ structural markup between two markets and what your margin looks like at any fee you set. The rest — sourcing, listing, region-lock checks — is the actual business you’d be building, and it deserves the same skepticism you’d apply to any gray-market trade where the counterparty has a Steamworks checkbox that can shut you down.


All pricing data in this article came from live calls to Steam’s public appdetails API on November 3, 2026. FX conversion came from open.er-api.com’s free endpoint the same day. The scanner was executed in full, exit code 0, on that date; no marketplace fee was assumed as fact — the 15% figure is a model parameter, not a verified rate for any specific platform.