Amazon Marketplace Currency Codes: A Lookup Table from the API

Amazon marketplace currency codes come from one SellerMagnet API call: /amazon-get-marketplaces. It takes no parameters at all and returns all 23 marketplaces keyed by marketplace ID, each carrying currency_code, currency_name, currency_symbol and a default geo_location postcode, for one credit. That one response is the full currency table below; no second call, and no per-marketplace lookup, is needed.

What does /amazon-get-marketplaces return?

A single GET request with your API key and no other parameters. The response is an object keyed by marketplace ID, one entry per marketplace, each with marketplace_domain, marketplace_name, currency_code, currency_name, currency_symbol and geo_location (the marketplace's default postcode, used by endpoints that localise results - see the geo_location guide for how that default is used). Marketplace IDs themselves are listed in the marketplace IDs reference.

Trimmed response of /amazon-get-marketplaces - two of the 23 entries, real values

{
  "success": true,
  "data": {
    "A1PA6795UKMFR9": {
      "marketplace_domain": "amazon.de",
      "marketplace_name": "Amazon DE",
      "currency_code": "EUR",
      "currency_name": "Euro",
      "currency_symbol": "€",
      "geo_location": "10115"
    },
    "ATVPDKIKX0DER": {
      "marketplace_domain": "amazon.com",
      "marketplace_name": "Amazon US",
      "currency_code": "USD",
      "currency_name": "United States Dollar",
      "currency_symbol": "$",
      "geo_location": "20001"
    }
  }
}

All 23 Amazon marketplace currencies

The full table below is the live response as of October 2026, sorted by domain. currency_symbol is the raw character Amazon's own pages use, including right-to-left symbols on amazon.ae, amazon.sa and amazon.eg - render those with the page's own text direction rather than assuming left-to-right placement, or the symbol lands on the wrong side of the amount.

Which marketplaces share a currency?

EUR is the only currency shared by more than two marketplaces: Germany, France, Italy, Spain, the Netherlands, Belgium and Ireland all answer in EUR, so a seller invoicing across those seven stores can total them directly without a conversion step. Every other currency belongs to exactly one marketplace - including the dollar sign, which is not one currency: amazon.com (USD) and amazon.com.mx (MXN) both display "$", so grouping by the symbol instead of currency_code would merge two different currencies.

How do I build a currency lookup table in Python?

Fetch the list once, cache it, then look up currency_code, currency_symbol and geo_location per marketplace ID from the cached copy. format_money() rounds to whole units for JPY and keeps two decimals everywhere else; by_currency() groups the 23 marketplaces by their currency the same way the table above does. get_with_retry comes from retry.py, and ApiError and new_session from sellermagnet.py, both published in the Python quickstart.

Install requests, set the key, run the script

pip install requests
export SELLERMAGNET_API_KEY="your-key-here"
python3 currency_table.py

currency_table.py: one cached call, a currency table and an invoice formatter

"""Build an Amazon marketplace currency lookup table for invoicing from /amazon-get-marketplaces.

/amazon-get-marketplaces takes no parameters at all - no marketplace ID, nothing to gate - so every
call answers all 23 marketplaces and costs 1 credit, success or not (FACTS.md "Marketplace
expansion"). This script caches the response for a week, builds a currency lookup table, groups
marketplaces that share a currency (useful for consolidating invoices) and formats one invoice line
per marketplace - the zero-decimal currency among the 23 (JPY) is rounded to whole units, not cents.
Helpers: sellermagnet.py and retry.py from https://sellermagnet-api.com/blog/amazon-product-api-python
"""
import json
import time
from pathlib import Path

from retry import get_with_retry
from sellermagnet import new_session

CACHE = Path("marketplace_currencies.json")
MAX_AGE = 7 * 24 * 3600          # the currency list changes rarely; every call costs a credit
ZERO_DECIMAL = {"JPY"}           # the only zero-decimal currency among the 23 marketplaces


def marketplaces(session) -> dict:
    if CACHE.exists() and time.time() - CACHE.stat().st_mtime < MAX_AGE:
        return json.loads(CACHE.read_text())
    data = get_with_retry(session, "amazon-get-marketplaces")
    CACHE.write_text(json.dumps(data))
    return data


def format_money(amount: float, currency_code: str, symbol: str) -> str:
    """JPY rounds to whole units; everything else keeps 2 decimals."""
    if currency_code in ZERO_DECIMAL:
        return f"{symbol}{round(amount):,}"
    return f"{symbol}{amount:,.2f}"


def by_currency(data: dict) -> dict:
    """Marketplace IDs grouped by currency code, so one converted total can cover several storefronts."""
    groups: dict[str, list] = {}
    for marketplace_id, info in data.items():
        groups.setdefault(info["currency_code"], []).append((marketplace_id, info["marketplace_domain"]))
    return groups


if __name__ == "__main__":
    data = marketplaces(new_session())
    invoice_amount = 1999.0   # one illustrative line item, in each marketplace's own currency units
    print(f"{len(data)} marketplaces, {len(by_currency(data))} currencies")
    for marketplace_id, info in sorted(data.items(), key=lambda kv: kv[1]["marketplace_domain"]):
        line = format_money(invoice_amount, info["currency_code"], info["currency_symbol"])
        print(f"{info['marketplace_domain']:<14} {info['currency_code']}  {line:>12}  "
              f"geo {info['geo_location'] or 'N/A'}")
    print()
    for currency_code, members in sorted(by_currency(data).items(), key=lambda kv: -len(kv[1])):
        domains = ", ".join(d for _, d in members)
        print(f"{currency_code}: {len(members)} marketplace(s) -> {domains}")

Output of currency_table.py (illustrative invoice amount of 1999.0 in each marketplace's own currency units)

23 marketplaces, 17 currencies
amazon.ae      AED   د.إ1,999.00  geo N/A
amazon.ca      CAD    C$1,999.00  geo K1A 0A1
amazon.co.jp   JPY        ¥1,999  geo 100-0001
amazon.co.uk   GBP     £1,999.00  geo SW1A 1AA
amazon.co.za   ZAR     R1,999.00  geo 0083
amazon.com     USD     $1,999.00  geo 20001
amazon.com.au  AUD    A$1,999.00  geo 2601
amazon.com.be  EUR     €1,999.00  geo 1000
amazon.com.br  BRL    R$1,999.00  geo 70040-904
amazon.com.mx  MXN     $1,999.00  geo 06000
amazon.com.tr  TRY     ₺1,999.00  geo 06690
amazon.de      EUR     €1,999.00  geo 10115
amazon.eg      EGP   ج.م1,999.00  geo 11511
amazon.es      EUR     €1,999.00  geo 28001
amazon.fr      EUR     €1,999.00  geo 75001
amazon.ie      EUR     €1,999.00  geo D02
amazon.in      INR     ₹1,999.00  geo 110001
amazon.it      EUR     €1,999.00  geo 00184
amazon.nl      EUR     €1,999.00  geo 1012
amazon.pl      PLN    zł1,999.00  geo 00-001
amazon.sa      SAR   ر.س1,999.00  geo 12271
amazon.se      SEK    kr1,999.00  geo 111 52
amazon.sg      SGD    S$1,999.00  geo 179431

EUR: 7 marketplace(s) -> amazon.fr, amazon.nl, amazon.de, amazon.es, amazon.ie, amazon.com.be, amazon.it
SAR: 1 marketplace(s) -> amazon.sa
SGD: 1 marketplace(s) -> amazon.sg
MXN: 1 marketplace(s) -> amazon.com.mx
PLN: 1 marketplace(s) -> amazon.pl
GBP: 1 marketplace(s) -> amazon.co.uk
JPY: 1 marketplace(s) -> amazon.co.jp
INR: 1 marketplace(s) -> amazon.in
CAD: 1 marketplace(s) -> amazon.ca
SEK: 1 marketplace(s) -> amazon.se
BRL: 1 marketplace(s) -> amazon.com.br
AED: 1 marketplace(s) -> amazon.ae
TRY: 1 marketplace(s) -> amazon.com.tr
AUD: 1 marketplace(s) -> amazon.com.au
ZAR: 1 marketplace(s) -> amazon.co.za
EGP: 1 marketplace(s) -> amazon.eg
USD: 1 marketplace(s) -> amazon.com

What does geo_location mean here?

geo_location is each marketplace's default postcode: the address other endpoints, such as /amazon-search, use when a request does not supply its own geo_location parameter. It is best-effort, not guaranteed - amazon.ae has no default at all, which is why its entry in the table above is blank. It is not related to currency; it travels in the same response only because the marketplaces endpoint is the one place all per-marketplace defaults live.

• currency_code is the ISO code billing systems expect (EUR, USD, JPY); use it as the join key, never the symbol.
• currency_symbol is a display string only; it can repeat across currencies ("$" on USD and MXN) and can be right-to-left (AED, SAR, EGP).
• geo_location is a default postcode for search and similar endpoints, blank on amazon.ae, unrelated to currency.
• The response never changes with a parameter: every call returns the same 23 entries, so there is nothing to validate before billing.

What does the API charge for this call?

The same rules as every other endpoint apply, just with no parameter checks in front of them, because there is no parameter to check. A bad or missing key is a free 401; the per-key concurrency cap is a free 429; an internal error is a refunded 500; upstream errors are billed 502s or 503s on every attempt. A successful call is billed once, regardless of how many of the 23 marketplaces you actually use afterwards.

Bottom line: one call to /amazon-get-marketplaces returns currency code, name, symbol and default postcode for all 23 Amazon marketplaces, 17 distinct currencies in total. Cache it, key everything on currency_code rather than the symbol, and round JPY to whole units. A free account comes with 150 credits after e-mail verification, and every endpoint is in the API documentation.