Amazon Sweden Product API: amazon.se Data in SEK, No Date First Available

To get Amazon Sweden product data, call the SellerMagnet API with marketplaceId=A2NODRKZP88ZB9: the request goes to amazon.se and prices come back in SEK. Offers, product lookup, search, deals, bestsellers and seller feedback all answer for amazon.se. Price history, sales estimates and the ASIN converter do not; they reject amazon.se with a free 400. On top of that, listedSinceDate from /amazon-product-lookup is always null on amazon.se, because the backend never recognises the Swedish "Date First Available" label.

What is different about the Amazon Sweden 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 one lookup field. The API resolves the amazon.se domain itself and reads prices in Swedish-format krona, so the decimal values you get back are plain numbers in SEK.

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

{
  "A2NODRKZP88ZB9": {
    "marketplace_domain": "amazon.se",
    "marketplace_name": "Amazon SE",
    "currency_code": "SEK",
    "currency_name": "Swedish Krona",
    "currency_symbol": "kr",
    "geo_location": "111 52"
  }
}

Which endpoints work on amazon.se?

Six of the ten endpoints only check that the marketplace ID is valid, so they answer on all 23 marketplaces, amazon.se 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.se 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 listedSinceDate always null on amazon.se?

productInfo.listedSinceDate is set by matching the page's "Date First Available" label text against a single hardcoded phrase list shared by every marketplace. That list has an entry for the German, English, Spanish, Italian, Japanese, Portuguese, French and Polish versions of the label, but none for Swedish. The label is on the amazon.se page like on any other store, but the backend never recognises it, so listedSinceDate stays null for every amazon.se listing. This is a label-matching gap, not a missing-data case: do not read a null listedSinceDate on amazon.se as "unknown listing age", because the same product checked on a covered marketplace, amazon.de for example, returns the real date.

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

The script below reads listedSinceDate for one ASIN on both stores to show the gap, then reads the live offers of three ASINs on each store side by side. 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.

se_vs_de.py - the same ASINs on amazon.se and amazon.de

"""Amazon Sweden (amazon.se) product check: listedSinceDate and history coverage, next to amazon.de.

amazon.se is marketplace A2NODRKZP88ZB9, priced in SEK. Two things are different from most EU stores:

1. amazon.se is NOT one of the 11 marketplaces with full price-history support (the SellerMagnetAPILambda
   config has no amazon.se 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", like amazon.ie.
2. On /amazon-product-lookup, productInfo.listedSinceDate comes from matching the page's "Date First Available"
   label against a shared, hardcoded phrase list (SellerMagnetAPILambda language_translation.py date_phrases).
   That list has an entry for German ("im angebot von"), English, Spanish, Italian, Japanese, Portuguese, French
   (twice) and Polish, but none for Swedish, so the Swedish label on amazon.se never matches and
   listedSinceDate is always null there, even though the information is on the page. amazon.de's German label
   is matched, so its listedSinceDate is populated normally.

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 = {"SE": "A2NODRKZP88ZB9", "DE": "A1PA6795UKMFR9"}   # amazon.se (SEK), 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
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)"
        print(f"{code} {marketplace}: {note}")

    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 (no Swedish date phrase matched)"
        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)

SE A2NODRKZP88ZB9: history endpoints skipped (free 400)
DE A1PA6795UKMFR9: history endpoints answer

lookup: listedSinceDate
SE    listedSinceDate=null (no Swedish date phrase matched)
DE    listedSinceDate=2024-03-11

asin        store   featured cur  sellers  holder / note
B0CL61F39H  SE        249.00 SEK        2  FBA seller A1SESELLER01
B0CL61F39H  DE        229.99 EUR        3  Amazon (A3JWKAKR8XB7XF)
B0IEONLY01  SE         99.00 SEK        1  FBM seller A3SESELLER03
B0IEONLY01  DE             - -          -  not listed in this store (billed 404)
B0NOOFFER1  SE             -            0  no featured offer
B0NOOFFER1  DE         15.99 EUR        1  FBM seller A4DESELLER04
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.
• listedSinceDate=null on SE is not a sign the listing is new or the data is missing: it is a label-matching gap in the backend, present on every amazon.se product.
• 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.se use its own bestseller category tree?

Yes. amazon.ie borrows the UK category tree because it has none of its own; amazon.se is not in that alias list, so category_id for amazon.se must come from amazon.se'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.se 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.se 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 A2NODRKZP88ZB9 for amazon.se, expect SEK, keep history calls for the 11 covered stores, and never trust a null listedSinceDate there as "unknown". 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.