Amazon Scraper API: Product Data to JSON

Short answer: For an authorized Amazon seller or vendor application, use the Selling Partner API (SP-API) Catalog Items API. Call getCatalogItem with an ASIN and a marketplaceIds query parameter, then select the JSON datasets you need with includedData.

The phrase “Amazon scraper API” can mean two different things. Some developers mean a third-party storefront extraction service. Amazon’s official APIs reviewed here are permissioned business APIs for selling partners and vendors; they are not an unrestricted public scraper. Your application needs the appropriate seller authorization and roles before the request can succeed.

Choose the Amazon API that matches your data

Need	API	What it does
Discover catalog data for an ASIN	Catalog Items API	Returns structured catalog JSON such as summaries, identifiers, images, attributes, classifications, dimensions, product types, sales ranks, and relationships.
Create or maintain your seller SKU	Listings Items API	Manages a seller’s own listings. Product Type Definitions provide the JSON schema requirements for a product type.
Retrieve prices and offers	Product Pricing API	A separate seller-only API for price and offer workflows in the documented v2022-05-01 version.

Use Catalog Items for product discovery, Listings for your inventory, and Product Pricing for offer data. A catalog response is not guaranteed to contain every field for every product; the available data depends on the item and the datasets requested.

Access requirements and authorization

SP-API access is tied to a selling partner and an application. Amazon states: “You must have a Professional selling account and be the primary account user to create an SP-API developer profile.” The seller page currently lists the Professional plan at $39.99 per month plus selling fees; check Amazon’s current selling-partner information before purchasing.

Public applications obtain partner permission through OAuth 2.0 with Login with Amazon (LWA). A private application can be self-authorized in the developer console. Roles determine which operations and resources the application may call, so request and qualify for the role required by Catalog Items or Product Pricing.

1. Create or join the relevant selling-partner account.
2. Create an SP-API developer profile and application in Seller Central.
3. Configure LWA credentials and the application’s AWS credentials as described in Amazon’s authorization documentation.
4. Obtain a selling-partner authorization token and sign each SP-API request with the required authentication headers.
5. Confirm that your application has the Catalog Items role before debugging request code.

Get a product record by ASIN

getCatalogItem requires two pieces of identity:

• asin: the product’s ASIN in the request path.
• marketplaceIds: the marketplace in which to resolve that ASIN.

The marketplace is required because catalog information is marketplace-specific. Do not treat an ASIN by itself as a complete lookup key.

Request shape

GET /catalog/2022-04-01/items/{asin}?marketplaceIds={marketplaceId}&includedData=summaries,attributes,identifiers,images

includedData is optional and defaults to summaries. Available groups in the reference are:

• attributes — structured item attributes keyed by attribute name.
• classifications — browse-node classifications.
• dimensions — catalog dimensions.
• identifiers — identifiers such as UPC and EAN.
• images — item image data.
• productTypes — associated product types.
• salesRanks — catalog sales ranks.
• summaries — summary information.
• relationships — variation and other relationship details.

Example response

{
  "asin": "B000000000",
  "summaries": [
    {
      "marketplaceId": "ATVPDKIKX0DER",
      "itemName": "Example product"
    }
  ],
  "identifiers": [
    {
      "marketplaceId": "ATVPDKIKX0DER",
      "identifiers": [
        {"identifierType": "EAN", "identifier": "0000000000000"}
      ]
    }
  ],
  "images": [],
  "attributes": {}
}

Field names and array contents vary by product and marketplace. Parse defensively: check that a dataset exists, select the marketplace entry you requested, and handle missing attributes.

Complete implementation pattern

The exact signing and token exchange depend on your SP-API application configuration. The examples below show the request parameters your authenticated client must send after it has obtained the required authorization.

cURL

curl --request GET \
  --url 'https://sellingpartnerapi-na.amazon.com/catalog/2022-04-01/items/B000000000?marketplaceIds=ATVPDKIKX0DER&includedData=summaries,attributes,identifiers,images' \
  --header 'x-amz-access-token: YOUR_LWA_ACCESS_TOKEN' \
  --header 'x-amz-date: 20261001T120000Z' \
  --header 'Authorization: AWS4-HMAC-SHA256 ...'

In production, generate the AWS Signature Version 4 Authorization value; never paste long-lived credentials into source control.

Python

import requests

endpoint = "https://sellingpartnerapi-na.amazon.com/catalog/2022-04-01/items/B000000000"
params = {
    "marketplaceIds": "ATVPDKIKX0DER",
    "includedData": "summaries,attributes,identifiers,images",
}
headers = {
    "x-amz-access-token": "YOUR_LWA_ACCESS_TOKEN",
    # Add the AWS SigV4 Authorization, x-amz-date, and host headers
    # produced by your SP-API signing library.
}

response = requests.get(endpoint, params=params, headers=headers, timeout=30)
response.raise_for_status()
product = response.json()
print(product.get("asin"))

Node.js

const endpoint = new URL(
  'https://sellingpartnerapi-na.amazon.com/catalog/2022-04-01/items/B000000000'
);
endpoint.searchParams.set('marketplaceIds', 'ATVPDKIKX0DER');
endpoint.searchParams.set(
  'includedData',
  'summaries,attributes,identifiers,images'
);

const res = await fetch(endpoint, {
  headers: {
    'x-amz-access-token': process.env.LWA_ACCESS_TOKEN,
    // Add AWS SigV4 Authorization, x-amz-date, and host headers.
  },
});

if (!res.ok) {
  throw new Error(`${res.status}: ${await res.text()}`);
}
const product = await res.json();
console.log(product.asin);

Normalize the JSON you store

def normalize_catalog_item(item, marketplace_id):
    def marketplace_record(records):
        for record in records or []:
            if record.get("marketplaceId") == marketplace_id:
                return record
        return None

    summary = marketplace_record(item.get("summaries")) or {}
    identifiers = marketplace_record(item.get("identifiers")) or {}
    return {
        "asin": item.get("asin"),
        "marketplace_id": marketplace_id,
        "item_name": summary.get("itemName"),
        "identifiers": identifiers.get("identifiers", []),
        "attributes": item.get("attributes", {}),
        "images": marketplace_record(item.get("images")),
        "relationships": item.get("relationships", []),
    }

Marketplace IDs and regional endpoints

Use the endpoint region and marketplace ID that match the selling partner and marketplace you are authorized to access. The United States marketplace ID commonly used in examples is ATVPDKIKX0DER; do not copy it for another country. Resolve the correct marketplace from Amazon’s current marketplace documentation and keep it as configuration, not a hard-coded assumption.

Pricing, offers, and listings

Catalog JSON is not a live price feed. For prices and offers, use the Product Pricing API and obtain its required Pricing role. For your own SKU data, use Listings Items and Product Type Definitions. These APIs have different permissions, request shapes, and response models; combining their results in your application is normal, but they are not interchangeable endpoints.

Rate limits, batching, and reliability

The Catalog Items reference displays a default usage plan of 2 requests per second with a burst of 2. This is the documented default for that operation, not a universal account-wide quota. Amazon may assign higher throughput to some selling partners, and the current usage plan can change.

• Read rate-limit headers when Amazon returns them.
• Implement exponential backoff with jitter for HTTP 429 responses.
• Use a bounded worker queue instead of launching one request per product.
• Cache catalog records according to your freshness requirements.
• Persist the ASIN, marketplace, request time, response status, and selected datasets for replayable debugging.

Amazon describes platform-level individual, batch, and bulk patterns. Batch operations may contain up to 20 similar requests where that operation supports batching. Feeds and reports support bulk workflows, but do not assume every Catalog Items operation has an equivalent batch or bulk endpoint.

Troubleshooting common errors

Symptom	Likely cause	Fix
401 or 403	Expired LWA token, invalid signature, missing role, or seller authorization.	Refresh the token, verify SigV4 clock and host values, and confirm the application and selling partner granted Catalog Items access.
400 missing marketplaceIds	The request included an ASIN but no marketplace.	Add one or more valid marketplace IDs as the required query parameter.
404 item not found	The ASIN is invalid for that marketplace or is not available to the authorized context.	Verify the ASIN spelling and marketplace, then test a known item in the same marketplace.
429 throttled	The operation’s usage plan was exceeded.	Reduce concurrency, honor rate-limit headers, and retry with exponential backoff and jitter.
JSON field is absent	The dataset was not requested or the product has no value for that field.	Add the relevant includedData value and treat missing arrays or objects as normal.
Pricing data is missing	Catalog Items does not provide the offer workflow you need.	Use Product Pricing with its seller authorization and Pricing role.
Signature mismatch	Canonical query order, region, service name, timestamp, or host differs between signing and sending.	Use Amazon’s signing guidance or a maintained SP-API client and keep the signed URL unchanged.

Performance and cost planning

Request only the datasets your application consumes. Smaller responses reduce transfer and parsing time. For repeated product pages, cache by (asin, marketplaceId, includedData) and refresh on a schedule appropriate to your use case. Separate catalog refresh jobs from user-facing requests so a throttle does not block your application.

SP-API access has eligibility and account costs. Amazon’s seller overview currently shows $39.99 per month plus selling fees for a Professional selling account; that commercial detail is volatile, so verify it before committing. Your own infrastructure costs also include token management, retries, storage, and monitoring.

Or skip the browser setup

If your requirement is a rendered page image rather than authorized seller catalog JSON, ScreenshotNeo provides a one-call website screenshot API. It is useful for visual QA, product-page archives, and workflows where you need the page as an image or PDF; it does not replace SP-API for structured Amazon catalog records.

Before capture, ScreenshotNeo accepts cookie and consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers. Its MCP server lets Claude, Cursor, and other MCP clients call take_screenshot, get_page_info, and capture_pdf.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://www.amazon.com/dp/B000000000 -o shot.webp

Python

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://www.amazon.com/dp/B000000000"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://www.amazon.com/dp/B000000000' }); const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

See the ScreenshotNeo API documentation for the 63 capture options, including full-page and element captures, device and retina settings, custom headers and cookies, waits, blocking rules, caching, signed links, asynchronous jobs, webhooks, bulk capture, and PDF output.

Try ScreenshotNeo free: 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.

FAQ

Is an Amazon scraper API legal to use?

That depends on the API, your authorization, Amazon’s terms, and applicable law. SP-API is designed for authorized seller and vendor business applications. Review the current Amazon terms and obtain the roles and permissions your use case requires.

Can I get product details with only an ASIN?

No. Catalog Items requires an ASIN and at least one marketplace ID.

Can I get Amazon prices through the Catalog Items API?

Use the separate Product Pricing API for seller price and offer workflows. Catalog metadata and pricing are distinct concerns.

Does every product have every catalog field?

No. The response depends on the requested datasets and the information available for that item and marketplace.

What is the default Catalog Items rate?

The reference displays 2 requests per second with a burst of 2. Treat that as the operation’s documented default usage plan and read current rate-limit information for your account.