Amazon Poland Product API: amazon.pl Data in PLN, No Price History

To get Amazon Poland product data, call the SellerMagnet API with marketplaceId=A1C3SOZRARQ6R3: the request goes to amazon.pl and prices come back in PLN. Offers, product lookup, search, deals, bestsellers and seller feedback all answer for amazon.pl. Price history, sales estimates and the ASIN converter do not; they reject amazon.pl with a free 400. Unlike amazon.se, listedSinceDate from /amazon-product-lookup works normally on amazon.pl, and unlike amazon.de, a captured amazon.pl price string groups thousands with a space, not a period.

What is different about the Amazon Poland API?

The request format is the same as for every other store: GET, query parameters, the key in the X-Api-Key header. What changes are a few values, the endpoint coverage and the number format of captured prices. The API resolves the amazon.pl domain itself and reads prices in zloty, so the decimal values you get back are plain numbers in PLN.

The amazon.pl entry of /amazon-get-marketplaces (data is keyed by marketplace ID)

{
  "A1C3SOZRARQ6R3": {
    "marketplace_domain": "amazon.pl",
    "marketplace_name": "Amazon PL",
    "currency_code": "PLN",
    "currency_name": "Polish Zloty",
    "currency_symbol": "zł",
    "geo_location": "00-001"
  }
}

Which endpoints work on amazon.pl?

Six of the ten endpoints only check that the marketplace ID is valid, so they answer on all 23 marketplaces, amazon.pl included. The three history endpoints read a data source that covers only 11 marketplaces and turn every other one away before the credit is taken: amazon.pl gets a 400 with the message "This endpoint is not available for the requested marketplace" followed by the list of supported stores. That call costs nothing, but it returns no data either.

Why is a captured amazon.pl price formatted differently than amazon.de?

Both stores show prices with a comma decimal separator, but the thousands grouping differs: amazon.de groups with a period ("1.299,99"), amazon.pl groups with a space ("1 299,99"). The API's own price-parsing step accounts for this (a marketplace's number format decides how the captured text is normalised before it becomes a float), so the buyBoxInfo.price and offers totalPrice fields you read from amazon.pl are already a correct number, in PLN. The format only matters if you later re-parse a raw price string yourself, for example from a screenshot or a page you fetch independently of this API: use the space-grouped rule for amazon.pl, not the German one.

How do I compare amazon.pl with amazon.de in Python?

The script below reads listedSinceDate for one ASIN on both stores, then reads the live offers of three ASINs on each store side by side, and prints each store's price-number format. It skips anything that is not a 10-character ASIN before paying, because the offers endpoint bills a malformed ASIN like any other request, and it stops the whole run on a 401/403 instead of looping. It uses sellermagnet.py (ApiError, new_session) and retry.py (get_with_retry) from the Python quickstart.

pl_vs_de.py - the same ASINs on amazon.pl and amazon.de

"""Amazon Poland (amazon.pl) product check: history coverage and price-number format, next to amazon.de.

amazon.pl is marketplace A1C3SOZRARQ6R3, priced in PLN. Two things to know before building on it:

1. amazon.pl is NOT one of the 11 marketplaces with full price-history support (the SellerMagnetAPILambda
   config has no amazon.pl entry in its history-domain map), so /amazon-product-statistics, estimated sales
   and the ASIN converter all answer it with a free 400 "This endpoint is not available for the requested
   marketplace", the same gate amazon.se and amazon.ie hit.
2. Unlike amazon.se, amazon.pl does NOT have a listedSinceDate gap: productInfo.listedSinceDate comes from
   matching the page's "Date First Available" label against a shared, hardcoded phrase list
   (SellerMagnetAPILambda language_translation.py date_phrases), and that list has a Polish entry
   ("pierwszej dostepnosci", the ASCII form of the stored phrase), so listedSinceDate is populated normally on
   amazon.pl, the same as on amazon.de (which has its own German entry). Also unlike amazon.de, amazon.pl's
   captured prices use a space thousands separator ("1 299,99 zł"), not amazon.de's period thousands separator
   ("1.299,99 EUR"): both use a comma decimal, so the two formats must be normalised differently before
   float().

Helpers: sellermagnet.py and retry.py from https://sellermagnet-api.com/blog/amazon-product-api-python
"""
import re

import requests

from retry import get_with_retry
from sellermagnet import ApiError, new_session

MARKETS = {"PL": "A1C3SOZRARQ6R3", "DE": "A1PA6795UKMFR9"}   # amazon.pl (PLN), amazon.de (EUR)
HISTORY_MARKETS = {"ATVPDKIKX0DER", "A2EUQ1WTGCTBG2", "A1AM78C64UM0Y8", "A2Q3Y263D00KWC", "A1F83G8C2ARO7P",
                   "A1PA6795UKMFR9", "A13V1IB3VIYZZH", "APJ6JRA9NG5V4", "A1RKKUPIHCS9HS", "A21TJRUUN4KGV",
                   "A1VC38T7YXB528"}   # the 11 marketplaces with full statistics, estimated sales, converter
SPACE_FORMAT = {"A2NODRKZP88ZB9", "A1C3SOZRARQ6R3", "AE08WJ6YKNBMC"}   # space thousands, comma decimal
ASINS = ["B0CL61F39H", "B0IEONLY01", "B0NOOFFER1", "not-an-asin"]
MAX_FAILED = 3                         # 502/503 are billed on every attempt: stop after 3 calls that keep failing


def history_allowed(marketplace_id):
    return marketplace_id in HISTORY_MARKETS


def product_info(session, asin, marketplace_id):
    """Read productInfo directly (not through lookup()): we need listedSinceDate, which lookup() drops."""
    from sellermagnet import get   # the quickstart's low-level helper, used by lookup() internally
    return get(session, "amazon-product-lookup", asin=asin, marketplaceId=marketplace_id)["productInfo"]


def featured(data):
    """(price, currency, holder, unique sellers) from one offers answer; price None when nothing is featured."""
    box, offers = data.get("buyBox") or {}, data.get("offers") or []
    sellers = len({o.get("sellerId") for o in offers if o.get("sellerId")})   # a seller can be listed twice
    currency = (data.get("currency") or {}).get("code", "")
    if data.get("buyBoxSuppressed") or not box.get("totalPrice"):
        return None, currency, "no featured offer", sellers
    if box.get("sellerId") == "Amazon":
        holder = f"Amazon ({box.get('amazonSellerId') or 'no first-party ID'})"
    else:
        holder = f"{box.get('fulfillmentType', '?')} seller {box.get('sellerId', '?')}"
    return round(box["totalPrice"], 2), currency, holder, sellers   # buyBox.totalPrice is not rounded upstream


def main():
    session = new_session()
    failed = 0
    for code, marketplace in MARKETS.items():
        note = "history endpoints answer" if history_allowed(marketplace) else \
            "history endpoints skipped (free 400)"
        fmt = "space thousands (1 299,99)" if marketplace in SPACE_FORMAT else "period thousands (1.299,99)"
        print(f"{code} {marketplace}: {note}, price format {fmt}")

    print("\nlookup: listedSinceDate")
    for code, marketplace in MARKETS.items():
        try:
            info = product_info(session, "B0CL61F39H", marketplace)
        except ApiError as err:
            if err.status in (401, 403):   # key or credits: every other call fails the same way
                print(f"stopped: {err}")
                return
            print(f"{code:<5} error {err}")
            continue
        since = info.get("listedSinceDate") or "null"
        print(f"{code:<5} listedSinceDate={since}")

    print(f"\n{'asin':<11} {'store':<5} {'featured':>10} {'cur':<4} {'sellers':>7}  holder / note")
    for raw in ASINS:
        asin = raw.strip().upper()
        if not re.fullmatch(r"[A-Z0-9]{10}", asin):
            print(f"{raw:<11} {'-':<5} {'-':>10} {'-':<4} {'-':>7}  skipped: not an ASIN (offers would bill it)")
            continue
        for code, marketplace in MARKETS.items():
            if failed >= MAX_FAILED:
                print(f"stopped after {MAX_FAILED} failed calls")
                return
            try:
                data = get_with_retry(session, "amazon-product-offers", asin=asin, marketplaceId=marketplace)
            except ApiError as err:
                if err.status in (401, 403):   # key or credits: every other call fails the same way
                    print(f"stopped: {err}")
                    return
                label = "not listed in this store (billed 404)" if err.status == 404 else f"error {err}"
                print(f"{asin:<11} {code:<5} {'-':>10} {'-':<4} {'-':>7}  {label}")
                failed += err.status >= 500
                continue
            except (requests.ConnectionError, requests.Timeout) as err:
                print(f"{asin:<11} {code:<5} {'-':>10} {'-':<4} {'-':>7}  error {type(err).__name__}")
                failed += 1
                continue
            price, currency, holder, sellers = featured(data)
            shown = f"{price:.2f}" if price is not None else "-"
            print(f"{asin:<11} {code:<5} {shown:>10} {currency:<4} {sellers:>7}  {holder}")


if __name__ == "__main__":
    main()

Output (illustrative data: two stores, a billed 404, a retried 502 and a skipped input)

PL A1C3SOZRARQ6R3: history endpoints skipped (free 400), price format space thousands (1 299,99)
DE A1PA6795UKMFR9: history endpoints answer, price format period thousands (1.299,99)

lookup: listedSinceDate
PL    listedSinceDate=2024-02-19
DE    listedSinceDate=2021-05-30

asin        store   featured cur  sellers  holder / note
B0CL61F39H  PL        129.00 PLN        1  FBA seller FBA02
B0CL61F39H  DE         32.50 EUR        1  FBA seller FBA02
B0IEONLY01  PL         49.99 PLN        1  FBM seller FBM05
B0IEONLY01  DE             - -          -  not listed in this store (billed 404)
B0NOOFFER1  PL             - PLN        0  no featured offer
B0NOOFFER1  DE          8.49 EUR        1  FBM seller FBM09
not-an-asin -              - -          -  skipped: not an ASIN (offers would bill it)

calls= 9

• sellers counts distinct seller IDs: the offers list can show the same seller twice (different delivery date or condition), so len(offers) overcounts.
• price format differs even between two euro-free EU stores: amazon.pl groups thousands with a space, amazon.de with a period. The fields this API returns are already normalised, so this only matters when parsing a raw page yourself.
• not listed in this store (billed 404): the offers endpoint answers an unknown ASIN with 404 "Invalid product" and charges the credit. The ASIN may well exist on the other store.
• no featured offer with 0 sellers is a listing without offers on that page, not an error. Confirm a stock-out with a second check before acting on it.

Does amazon.pl use its own bestseller category tree?

Yes. amazon.ie borrows the UK category tree because it has none of its own; amazon.pl is not in that alias list, so category_id for amazon.pl must come from amazon.pl's own tree (category explorer). An ID from another marketplace's tree, a German one for example, fails with "Invalid CategoryId", a billed 400.

What does an amazon.pl check cost?

1 credit per request, as on every store. The comparison script costs 2 credits per ASIN (one lookup call per store), plus each billed retry: a 502 or 503 is charged on every attempt, a 500 without Retry-After is refunded. The 404 for an ASIN that a store does not have is billed; an invalid marketplace ID and the history endpoints' amazon.pl 400 are free. The example run made 9 calls, 2 for the listedSinceDate check, 6 for three ASINs and 1 retried 502. For the whole picture across stores, see API marketplace coverage and the marketplace IDs list.

Bottom line: use A1C3SOZRARQ6R3 for amazon.pl, expect PLN with a space-grouped price format, keep history calls for the 11 covered stores, and remember amazon.pl's own category tree and 00-001 default postcode. To compare prices across more stores, see comparing Amazon prices across marketplaces; the offers endpoint page lists every field, and a free account includes 150 credits.