The fastest way to get Amazon product data as JSON is to call an endpoint that has already done the scraping, rendering, and parsing, and just hands you fields. This guide walks the Capzy Data API's Amazon coverage end to end: search, product detail, reviews, offers, bestsellers, and sellers, with real request and response shapes you can copy.

# Why scraping Amazon yourself is a grind

Amazon is one of the most-scraped sites on the internet, and it behaves accordingly. Product pages come in dozens of markup variants that change without notice. Listings render differently by region, device, and test bucket. And traffic that looks automated gets challenged early and often; we covered that side of the problem in [Amazon captchas and scraping](https://capzy.ai/blog/amazon-captcha-scraping).

None of that work is differentiating for your product. The data is the point: titles, prices, ratings, availability. The endpoint layer exists so you can start at the data.

# Search: from query to product list

`amazon/search` takes a query and a marketplace and returns ranked results:

    curl -X POST https://api.capzy.ai/v1/data/amazon/search \
      -H "Content-Type: application/json" \
      -d '{
        "clientKey": "YOUR_DATA_API_KEY",
        "params": {"query": "wireless earbuds", "domain": "com", "page": 1},
        "freshness": "auto"
      }'

Each result row carries the product's `asin`, its `position` in the results, the `title`, and the marketplace `domain`. The `asin` is the key that unlocks every other Amazon endpoint, so a common pattern is search first, then fan out.

# Product detail: the whole page, parsed

`amazon/product_detail` takes an ASIN and returns the fields you would otherwise dig out of the page:

    import requests
    
    resp = requests.post(
        "https://api.capzy.ai/v1/data/amazon/product_detail",
        json={
            "clientKey": "YOUR_DATA_API_KEY",
            "params": {"asin": "B0CHWRXH8B", "domain": "com"},
            "freshness": "fresh",
        },
    )
    print(resp.json())

A trimmed real response:

    {
      "asin": "B0CHWRXH8B",
      "title": "Apple AirPods Pro (2nd Generation) Wireless Ear Buds...",
      "brand": "Apple Store",
      "price": 163.19,
      "currency": "USD",
      "rating": 4.7,
      "reviews_count": 28856,
      "availability": "Only 1 left in stock - order soon."
    }

Note the `freshness: "fresh"` there: for a price or availability check you usually want a live pull. For enrichment jobs where an hour-old record is fine, `auto` avoids hammering the same page.

# The rest of the Amazon family

The same request shape covers the whole surface:

* `amazon/reviews`: paginated reviews for an ASIN
* `amazon/offers`: the buy-box and competing offers for a listing
* `amazon/bestsellers` and `amazon/new_releases`: category charts
* `amazon/deals`: current deal listings
* `amazon/seller`**,** `amazon/seller_products`**,** `amazon/seller_feedback`: storefront data for marketplace sellers
* `amazon/category` **and** `amazon/categories`: category browse trees
* `amazon/autocomplete`: search suggestions for a prefix

If you have ever built keyword tooling, the autocomplete endpoint alone is a feature: it is the same suggestion stream shoppers see as they type.

# Going international

Every Amazon endpoint takes a `domain` parameter that selects the marketplace: `com` for the US, [`co.uk`](http://co.uk), `de`, `fr`, [`co.jp`](http://co.jp), [`com.au`](http://com.au), and the rest of the 20 supported marketplaces. The response schema stays identical across all of them, so a price-comparison feature across five countries is the same code running five parameter sets, not five scrapers.

# Keeping a catalog fresh without re-pulling everything

Real Amazon workloads are rarely one call. Three features carry the load at volume:

* **Batch requests**: send many ASINs against `product_detail` in one call, and each query is tracked as its own job
* **Freshness modes**: `cached` and `auto` let enrichment reads reuse recent records instead of hitting the live site for every caller
* **Saved tasks and schedules**: store "bestsellers in this category, every morning" once, then collect the runs from your request history or export them as CSV, JSON, or XLSX

# A tiny end-to-end example

Search for a product, take the top result, and pull its full detail:

    import requests
    
    BASE = "https://api.capzy.ai/v1/data"
    KEY = "YOUR_DATA_API_KEY"
    
    search = requests.post(f"{BASE}/amazon/search", json={
        "clientKey": KEY,
        "params": {"query": "mechanical keyboard", "domain": "com", "page": 1},
        "freshness": "auto",
    }).json()
    
    top = search["results"][0]
    
    detail = requests.post(f"{BASE}/amazon/product_detail", json={
        "clientKey": KEY,
        "params": {"asin": top["asin"], "domain": "com"},
        "freshness": "fresh",
    }).json()
    
    print(top["asin"], detail["title"], detail.get("price"))

That is the entire integration. No headless browser, no HTML, no selectors, and nothing to fix when the page changes next month.

# Wrap-up

Amazon data as JSON is a solved problem when the parsing lives behind an endpoint. Start with `amazon/search` for discovery, `amazon/product_detail` for depth, and layer reviews, offers, and seller endpoints as your feature needs them. The full parameter and schema reference for every endpoint lives in the Data API docs.

How to Get Amazon Product Data as JSON With One API Call