How to Scrape Amazon Product Data in 2026 (API & Python)

The fastest way to scrape Amazon product data in 2026 is to call a structured Amazon API that returns normalized JSON — title, ASIN, price, availability, rating, and review count — instead of running and babysitting your own scraper. You can build a DIY scraper in Python, but Amazon's anti-bot defenses, rotating layouts, and CAPTCHAs make it costly to keep working. This guide covers all three approaches, what each returns, where each breaks, and the legal basics.

Is it legal to scrape Amazon product data?

Public product data — titles, prices, ratings, and reviews — is generally lower-risk to collect: in the US, hiQ Labs v. LinkedIn held that accessing publicly available data does not violate the Computer Fraud and Abuse Act, and facts like prices are not copyrightable. That said, Amazon's Conditions of Use prohibit automated access, so you can face blocks or bans, and personal data triggers privacy laws. Rules of thumb:

• Collect only public product data; avoid personal data and anything behind a login.
• Respect rate limits and don't degrade the service.
• Review Amazon's terms and your own compliance requirements.

This is not legal advice — when in doubt, talk to a lawyer.

Option 1: DIY in Python (and why it breaks)

For a single page you might reach for requests + BeautifulSoup, parse the product fields, and export to CSV — escalating to a headless browser when JavaScript or anti-bot checks get in the way:

import csv
import requests
from bs4 import BeautifulSoup

headers = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
    "Accept-Language": "en-US,en;q=0.9",
}
resp = requests.get("https://www.amazon.com/dp/B0DGJ736JM", headers=headers, timeout=30)
soup = BeautifulSoup(resp.text, "html.parser")

title = soup.select_one("#productTitle")
price = soup.select_one(".a-price .a-offscreen")
rating = soup.select_one("#acrPopover .a-icon-alt")

row = {
    "asin": "B0DGJ736JM",
    "title": title.get_text(strip=True) if title else None,
    "price": price.get_text(strip=True) if price else None,
    "rating": rating.get_text(strip=True) if rating else None,
}

with open("amazon.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=row.keys())
    writer.writeheader()
    writer.writerow(row)
# ...on a good day. On a bad day: a CAPTCHA, a 503, or a redirect to a bot check.

It demos well and then breaks at scale:

• Anti-bot — CAPTCHAs and IP bans push you into proxy rotation and fingerprinting.
• Layout churn — Amazon changes the DOM and your selectors silently break.
• ASIN and variation sprawl — prices and availability vary by variant, seller, and region.
• Scale — reliable collection means proxy pools, retries, and monitoring you have to run.

Most of the cost is not the first scrape — it is keeping it alive.

Option 2: No-code tools

Visual extractors and browser extensions handle the page for you and export CSV or JSON. They are fine for one-off exports, but less convenient when you need Amazon data inside a product or pipeline, on a schedule, with predictable fields.

Option 3: A structured Amazon API

For repeatable, in-product workflows, an Amazon scraping API gives you documented endpoints that return normalized JSON — no browser, no selectors, no proxy pool to run. Fetch a product by ASIN:

curl https://api.crawlora.net/api/v1/amazon/product/B0DGJ736JM \
  -H "x-api-key: $CRAWLORA_API_KEY"

The same call in Python:

import requests

resp = requests.get(
    "https://api.crawlora.net/api/v1/amazon/product/B0DGJ736JM",
    headers={"x-api-key": "YOUR_API_KEY"},
)
data = resp.json()["data"]
print(data["title"], data["price"], data["rating"])

The response is normalized JSON you can store directly (fields shown are illustrative — check the docs for the current schema):

{
  "code": 200,
  "msg": "OK",
  "data": {
    "asin": "B0DGJ736JM",
    "title": "Example product",
    "price": 189,
    "currency": "USD",
    "availability": "In Stock",
    "rating": 4.4,
    "review_count": 1055
  }
}

Collecting a whole result set? Use the search endpoint:

curl "https://api.crawlora.net/api/v1/amazon/search?query=wireless+earbuds&page=1" \
  -H "x-api-key: $CRAWLORA_API_KEY"

What you can collect

Where the public listing exposes them, the fields fall into a few groups:

• Product identity — title, ASIN, brand or seller, images, and the product URL.
• Pricing — current price, currency, strikethrough/list price, and availability.
• Social proof — average rating, review count, and review samples; for full review mining, page the product's reviews.
• Listing metadata — search-result position and badges (Prime, Best Seller, Amazon's Choice), plus the ASIN or query context you requested.

Re-run on a schedule and store one row per ASIN per run to build a price-and-rating history.

Limitations and common challenges

Even with a good API, keep a few Amazon realities in mind:

• Personalized results. Amazon tailors results to location and history, so two requests can differ; locale parameters reduce but don't eliminate this.
• Pagination caps. Search is capped at roughly 20 pages per query — split by category or filters to go deeper.
• Price volatility. Prices change frequently, so for accurate tracking you need to re-scrape on a schedule, not once.
• Anti-bot for DIY. Direct scraping faces CAPTCHAs, behavioral analysis, and cookie/fingerprint checks; a structured API absorbs proxy routing, rendering, and retries behind the endpoint.
• Marketplace and currency. The endpoint defaults to amazon.com (USD); confirm coverage before relying on other regional marketplaces.

Where this gets used

Structured Amazon data powers a few common workflows:

• Price & MAP monitoring — track prices and availability and flag MAP violations. See the price & MAP monitoring use case.
• Product monitoring — watch listings, ratings, and Buy-Box changes via Amazon product monitoring.
• E-commerce intelligence — compare catalogs and assortment across marketplaces with e-commerce product intelligence.

Sources

Start collecting

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Test the product endpoint in the Playground, check the response schema in the API docs, and review credit costs on the pricing page. Running the same playbook on another marketplace? See how to scrape eBay and how to scrape Shopify stores. For the bigger picture, see best Amazon scraping APIs, how to choose a web scraping API, and ScraperAPI alternatives.