Amazon Egypt Product API: amazon.eg Data in EGP, Bestsellers by Name

To use the SellerMagnet API as an Amazon Egypt product API, call it with marketplaceId=ARBP9OOSHTCHU: the request goes to amazon.eg and prices come back in EGP, with 11511 as the default delivery postcode. Offers, product lookup, search, deals, bestsellers and seller feedback all answer for amazon.eg; price history, sales estimates and the ASIN converter return a free 400. Bestsellers also take an English category name, which is handy as long as you check where the name landed.

What is different about the Amazon Egypt product 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 language of the page the data comes from. Prices come back as plain decimal numbers in EGP, so you never parse the Arabic pound sign yourself; use currency_code when you display them.

The amazon.eg entry of /amazon-get-marketplaces as sent (keyed by marketplace ID; the pound sign arrives JSON-escaped)

{
  "ARBP9OOSHTCHU": {
    "currency_code": "EGP",
    "currency_name": "Egyptian Pound",
    "currency_symbol": "\u062c.\u0645",
    "geo_location": "11511",
    "marketplace_domain": "amazon.eg",
    "marketplace_name": "Amazon EG"
  }
}

Which endpoints answer for amazon.eg?

Six of the ten endpoints have no marketplace coverage gate, so they answer on all 23 marketplaces, amazon.eg included. The three history endpoints cover only 11 marketplaces and turn every other one away before the credit is taken: amazon.eg 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, so plan any amazon.eg price tracking around your own offers snapshots.

What does the default postcode 11511 change?

Every marketplace except amazon.ae has a default delivery postcode, and for amazon.eg it is 11511. When you send no geo_location, the API tries to set 11511 as the delivery location before it reads offers, search results or deals; product lookup always tries 11511, even when you send geo_location. Setting a location is best-effort: when Amazon does not accept it, the call still answers, read for the location Amazon applies by default. So shippingPrice, totalPrice and deliveryDate are indicative. Compare priceWithoutShipping between runs, and compare the same seller, because which offer is featured can itself depend on the shipping location. The search location guide shows how the location step behaves in detail.

How do I get amazon.eg bestsellers by category name?

Since 1 November 2026, category_id on /amazon-bestsellers takes either a category ID or a category name. amazon.eg has its own tree with 24 top-level categories (slugs such as electronics) and about 22,900 nodes, and its names are in English even though the store pages are Arabic, so send English names: an Arabic name matches nothing. A name is matched to exactly one node, and the 200 response then carries resolved_category (ID, name and path) next to data. A name that fits several nodes equally well, or none, gets a 400 that costs no credit and lists the candidates (for no match, the closest names) with their IDs.

Always read where the name landed. Short names do not always land where you expect: on amazon.eg's tree at the time of writing (2 November 2026), these names resolve as follows.

headphones matches a node named exactly "Headphones" under car electronics, which beats the Electronics node "Headphones, Earbuds & Accessories", and smartphones lands on toy phones. When two nodes tie, nothing is charged and you get the choice instead, as with chargers:

The free 400 for category_id=chargers on amazon.eg (generated from the tree)

{
  "candidates": [
    {
      "category_id": "21833004031",
      "name": "Chargers",
      "path": "Electronics > Mobile Phones & Communication > Accessories > Chargers"
    },
    {
      "category_id": "21869435031",
      "name": "Chargers",
      "path": "Home & Garden > Mowers & Outdoor Power Tools > Outdoor Power Tool Accessories > Chargers"
    }
  ],
  "error": "Bad request",
  "message": "'chargers' matches 2 categories on amazon.eg. Pass the category_id of the one you want.",
  "success": false
}

How do I scout amazon.eg bestsellers in Python?

The script below reads the bestseller list of one category by name, checks that the match sits under the department you expected, then reads the live offers of the top five ASINs and prints the featured price, who holds it and how many distinct sellers are listed. It skips cards without a valid ASIN and repeated products before paying, caps calls that keep failing and stops the whole run on a 401/403. It uses sellermagnet.py (ApiError, new_session) and retry.py (get_with_retry) from the Python quickstart. The quickstart helper returns only data, so the script reads the department from data.link instead of resolved_category.

eg_bestseller_scout.py - who sells the top amazon.eg bestsellers of one category

"""Amazon Egypt (amazon.eg) bestseller scout: who sells the top products of one category, prices in EGP.

amazon.eg is marketplace ARBP9OOSHTCHU. The script makes two kinds of calls:

1. /amazon-bestsellers for one category (1 credit). category_id takes a category ID or a category name from
   amazon.eg's own tree, whose names are in English. A name is matched to one node and a short name can land
   somewhere unexpected ("headphones" resolves to a car electronics node), so the script reads the department
   from data.link and stops before buying offers calls when it is not the one you expected.
2. /amazon-product-offers for the top ASINs of that list (1 credit each): featured price, who holds it (Amazon
   itself shows sellerId "Amazon" with amazonSellerId A1ZVRGNO5AYLOV) and how many distinct sellers.

amazon.eg has no price history in the API (statistics, estimated sales and the converter answer a free 400), so
this is a snapshot. Without GEO the API tries amazon.eg's default postcode 11511 (best-effort).

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

EG = "ARBP9OOSHTCHU"                   # amazon.eg, prices in EGP
AMAZON_EG = "A1ZVRGNO5AYLOV"           # Amazon's own seller ID on amazon.eg (offers: amazonSellerId)
CATEGORY = "power banks"               # a category ID or an English category name from amazon.eg's tree
EXPECT = "electronics"                 # top-level slug the category must sit under before offers are bought
COUNT = 10                             # bestseller cards to read: 1 credit for up to 50
TOP = 5                                # offers calls, 1 credit per ASIN
GEO = None                             # None = amazon.eg's default postcode (11511)
MAX_FAILED = 3                         # 502/503 are billed on every attempt: stop after 3 calls that keep failing
ASIN_RE = re.compile(r"[A-Z0-9]{10}")


class Stop(Exception):
    """401/403: the key or the credits are the problem, so every further call would fail the same way."""


def call(session, endpoint, **params):
    try:
        return get_with_retry(session, endpoint, **params)
    except ApiError as err:
        if err.status in (401, 403):
            raise Stop(str(err)) from err
        raise


def department(link):
    """Top-level slug of the bestseller page that was read: .../gp/bestsellers/<slug>[/<node id>]?pg=1."""
    match = re.search(r"/gp/bestsellers/([^/?]+)", link or "")
    return match.group(1) if match else ""


def featured(data):
    """(item price, shipping, holder, distinct sellers); item is 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
    item = box.get("priceWithoutShipping") or 0.0
    if data.get("buyBoxSuppressed") or item <= 0:                 # 0.0 = no readable price, never a real price
        return None, None, "no featured offer", sellers
    if box.get("sellerId") == "Amazon":
        holder = "Amazon" if box.get("amazonSellerId") == AMAZON_EG else \
            f"Amazon ({box.get('amazonSellerId') or 'no first-party ID'})"
    else:
        holder = f"{box.get('fulfillmentType', '?')} seller {box.get('sellerId', '?')}"
    return round(item, 2), round(box.get("shippingPrice") or 0.0, 2), holder, sellers


def row(rank, asin, listed="-", item="-", ship="-", sellers="-", note=""):
    print(f"{rank:>4}  {asin:<10}  {listed:>9}  {item:>9}  {ship:>6}  {sellers:>7}  {note}")


def main():
    session = new_session()
    try:
        page = call(session, "amazon-bestsellers", category_id=CATEGORY, marketplaceId=EG, count=COUNT)
    except Stop as err:
        print(f"stopped: {err}")
        return
    except ApiError as err:     # an unknown or ambiguous category name is a free 400 that names the matches
        print(f"bestsellers failed: {err}")
        return
    except (requests.ConnectionError, requests.Timeout) as err:
        print(f"bestsellers failed: {type(err).__name__}")
        return
    root = department(page.get("link"))
    print(f"category {CATEGORY!r} -> {page.get('categoryId')} under {root or '?'} (amazon.eg, EGP)")
    if root != EXPECT:
        print(f"stopped: not under {EXPECT!r}, pass the category ID you want (1 credit spent, no offers called)")
        return

    seen, skipped, checked, featured_n, by_amazon, failed = set(), 0, 0, 0, 0, 0
    print()
    row("rank", "asin", "card EGP", "featured", "ship", "sellers", "holder / note")
    for card in page.get("bestsellers") or []:
        if checked == TOP:
            break
        asin = str(card.get("asin") or "").strip().upper()
        if not ASIN_RE.fullmatch(asin) or asin in seen:
            skipped += 1                     # a card without an ASIN, or the same product twice
            continue
        if failed >= MAX_FAILED:
            print(f"stopped after {MAX_FAILED} failed calls")
            break
        seen.add(asin)
        checked += 1
        rank = str(card.get("rank") or "-")
        price = (card.get("price") or {}).get("price")
        listed = f"{price:.2f}" if isinstance(price, (int, float)) and price > 0 else "-"
        params = {"asin": asin, "marketplaceId": EG}
        if GEO:                              # omitted = amazon.eg's default postcode
            params["geo_location"] = GEO
        try:
            data = call(session, "amazon-product-offers", **params)
        except Stop as err:
            print(f"stopped: {err}")
            return
        except ApiError as err:
            row(rank, asin, listed, note=f"billed {err}" if err.status == 404 else f"error {err}")
            failed += err.status >= 500
            continue
        except (requests.ConnectionError, requests.Timeout) as err:
            row(rank, asin, listed, note=f"error {type(err).__name__}")
            failed += 1
            continue
        item, ship, holder, sellers = featured(data)
        if item is None:
            row(rank, asin, listed, sellers=sellers, note=holder)
            continue
        featured_n += 1
        by_amazon += holder == "Amazon"
        row(rank, asin, listed, f"{item:.2f}", f"{ship:.2f}", sellers, holder)
    print(f"\nAmazon ({AMAZON_EG}) holds {by_amazon} of {featured_n} featured offers; "
          f"{checked} ASINs checked, {skipped} cards skipped")


if __name__ == "__main__":
    main()

Output (illustrative data: a name match, a billed 404, a retried 502, two skipped cards)

category 'power banks' -> 21833176031 under electronics (amazon.eg, EGP)

rank  asin         card EGP   featured    ship  sellers  holder / note
   1  B0EGSAMPL1    1249.00    1199.00    0.00        2  Amazon
   2  B0EGSAMPL2     689.00     649.00   35.00        2  FBM seller A3EGSELLER02
   4  B0EGSAMPL4    1575.00          -       -        -  billed 404: Invalid product
   6  B0EGSAMPL5          -          -       -        0  no featured offer
   7  B0EGSAMPL6     459.00     449.00    0.00        3  Amazon

Amazon (A1ZVRGNO5AYLOV) holds 2 of 3 featured offers; 5 ASINs checked, 2 cards skipped

• card EGP is the price on the bestseller card (a variation range shows its low end); featured is the item price of the featured offer from the offers endpoint, without shipping. The two can differ.
• Amazon means the featured offer says sellerId "Amazon" and carries amazon.eg's first-party ID A1ZVRGNO5AYLOV in amazonSellerId. The summary counts only those.
• sellers counts distinct seller IDs: the offers list can show the same seller twice (different delivery date or condition), so len(offers) overcounts.
• billed 404: Invalid product is an ASIN the offers endpoint could not find; the credit is charged and the call is not retried.
• 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.

Why is listedSinceDate always null on amazon.eg?

The API reads amazon.eg in Arabic, the same as amazon.sa and amazon.ae. productInfo.listedSinceDate is set by matching the page's "Date First Available" label against one phrase list shared by every marketplace, and that list has no Arabic entry. So listedSinceDate stays null for every amazon.eg product; it is a label-matching gap, not a sign that the listing is new. The Arabic page also means that title, bestseller titles and category names from the page can come back in Arabic, which is why the script prints ASINs, not titles: join and deduplicate your data on the ASIN. Sales ranks are the exception that needs no work: amazon.eg shows them with Arabic-Indic digits, and bestsellerRanks returns them as plain integers.

Credit cost of an amazon.eg check

1 credit per request, as on every store. The script costs 1 credit for the bestseller list (up to 50 cards) plus 1 credit per ASIN it checks, 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 the offers endpoint cannot find is billed. An unknown or ambiguous category name or an unknown category ID, an invalid marketplace ID and the history endpoints' amazon.eg 400 are free. The example run made 7 calls: 1 for the list, 5 offers calls and 1 retried 502. For the whole picture across stores, see API marketplace coverage and the marketplace IDs list.

Bottom line: use ARBP9OOSHTCHU for amazon.eg, expect EGP with 11511 as the default postcode, keep history calls for the 11 covered stores, send English category names and check where they landed. Browse the IDs in the category explorer, and a free account includes 150 credits.