Guides

How to Scrape Amazon Product Data: 4 Methods

Learn how to scrape Amazon product data with APIs, no-code tools or Python. Compare costs, check permissions, and export product fields to CSV.

Kevin LinKevin Lin15 min read

There are four ways to scrape Amazon product data: the official Creators API, a managed scraper API, a no-code tool, or a Python script. Choose by the fields you need, your eligibility, your budget and who will maintain the integration. This guide compares the options and shows how to export product fields to CSV with Python.

Key takeaways

  • Affiliate publishing: evaluate the Creators API if you meet Amazon’s eligibility requirements and your use fits its license.
  • Structured data without maintaining a parser: compare scraper APIs by marketplace coverage, fields and cost per usable result.
  • Small, occasional exports: a no-code tool can reduce setup work, but check its pagination, export and scheduling limits.
  • Custom parsing and storage: Python offers control, with proxy costs, layout changes and access failures left to you.

What Amazon product data can you scrape?

Amazon homepage

Product pages commonly display a title, price, rating, main image, ASIN, availability and seller information. Which fields are visible depends on the marketplace, delivery location, selected variation, seller and whether the visitor is signed in. Search pages expose a subset of these fields, and their pagination is not a reliable way to enumerate the entire catalog.

Ratings and review summaries may be visible on product pages, while full review access can require signing in. The Python example below extracts title, price, rating and image URL from product-page HTML. Collecting Amazon offers and written reviews involves additional data sources, pagination checks and separate CSV records.

Before you scrape: access and data-use rules

Amazon’s Conditions of Use exclude collection of product listings, descriptions and prices, and the use of data-mining or extraction tools, from the ordinary license. The restriction is not limited to signed-in pages. Use an official API within its license, appropriately licensed data, or a collection route for which you have permission.

The site’s robots.txt provides crawler directives; it does not grant a data-use license or settle the legal status of a project. Marketplace terms and applicable law also matter.

For a permitted collection workflow, keep request rates modest, stop on access challenges or rate limits, and store only the fields you need. Reviews and seller details can contain personal information, so a product-data project should not collect them by default.

How to choose a method

Five questions narrow the choice.

  1. How many pages a month?
    Compare your planned volume with the actual export limits, scheduling options and billing units. A one-off export and a recurring monitoring job can need different tools even at the same page count.

  2. Which fields?
    Check whether the tool returns the exact fields you need, including title, price and rating. Buy box details, seller data, rank and variations need a tool that parses them for you or a script you maintain.

  3. Do you qualify for the official API?
    If you run an Amazon affiliate site, the official route may cover you.

  4. Who maintains it?
    Amazon changes its page layouts often, so a script needs regular fixes. Browserless warns that Amazon runs frequent layout tests, so the same product can come back with different markup.

  5. What is the cost per successful page?
    Include failed requests, retries, traffic and maintenance. Verify what each vendor considers a billable result.

Method
Best for
Data you get
Cost / access model
Main limit
Official Amazon API (Creators API)
Affiliate sites showing product details
Catalog data Amazon exposes, by ASIN, keyword or category
Tied to Amazon Associates eligibility
Needs an Associates account and recent sales
Scraper API
Steady volume without maintaining parsers
Vendor-specific structured fields
Per request, record or result
Costs add up at scale; output differs by vendor
No-code tool or extension
Small, one-off jobs by non-developers
The fields on the pages you point it at
Free tier or monthly plan
Export and scheduling limits vary by tool
Python script with residential proxies
Custom fields, moderate volume, full control
Whatever you parse
Proxy traffic plus your time
You maintain parsing and handle access errors

Method 1: the official Amazon API

The Amazon Creators API provides catalog access through SearchItems, GetItems, GetVariations and GetBrowseNodes. It is intended for publishers, influencers and affiliate partners building shopping experiences, rather than unrestricted catalog extraction.

Amazon lists enrollment in the Associates program for the target marketplace and at least 10 qualifying sales within the past 30 days as prerequisites for access to the PA API through the Creators API. You also need to register for API access, generate credentials and follow the API license for storage and reuse.

Start here if you are an eligible affiliate publisher. For market research, check whether the API’s fields and data-use license fit your project before building around it.

Method 2: a scraper API

A scraper API accepts a URL, ASIN or search query and returns data in a vendor-defined format. It can reduce proxy management and parser maintenance. Compare the published offers below by billing unit, required fields and marketplace coverage.

Provider Published offer Key buying consideration
Bright Data 5,000 free records per month; pay as you go at $1.50 per 1,000 records Required endpoint, output fields and what counts as a successful record
Decodo Amazon page advertises a free plan of up to 2,000 requests and pricing starting at $0.15 per 1,000 requests Credit usage for your target and rendering options; the headline starting rate is not necessarily the effective rate for your workload
Apify Amazon Product Scraper Listed from $3.00 per 1,000 results This specific actor’s input, output and full charges; other Apify actors have different terms
SerpApi Free plan with 250 searches per month Supported Amazon endpoint, fields and query limits

A request, record, result and search are different units. Calculate total billed cost ÷ usable results, accounting for missing fields and duplicates, and check the plan terms before subscribing.

Pick a scraper API when structured output and reduced maintenance matter more than controlling every parsing decision.

Method 3: no-code tools and extensions

Browser extensions and point-and-click tools let you select fields and export results without writing a parser. For example, Web Scraper publishes an Amazon listings scraper for category and search pages. Compare its sample output with your requirements before paying for a workflow.

These tools can suit a small, occasional export such as an authorized price research sheet. Check whether the tool follows pagination, handles variations, exports the format you need and supports scheduled runs. Test for missing or duplicate products rather than assuming that an export contains every search result.

Method 4: Python with residential proxies

The first three methods are usually the better starting points when you want managed access, a ready-made export, or the official affiliate workflow. This section goes deeper on Python because it is the option that leaves field selection, parsing, storage and request pacing in your hands.

A script gives you control over fields, collection timing and storage. It also leaves layout changes, network failures and access restrictions to you.

Socks5.IO e-commerce proxy page for collecting public product and price data

What proxies do and do not fix

The core value of a proxy lies in taking over identity masking at the network layer. By constantly rotating or locking an exit IP in your target region, it ensures your Python scraper or HTTP client won’t be outright blacklisted by target websites for “high-frequency requests from a single IP.”

Of course, comprehensive anti-bot evasion is multi-dimensional (requiring, for example, browser fingerprinting and User-Agent optimization). However, across all these components, having a high-purity proxy network with precise session control is the first and most critical step. The example below demonstrates how to use a sticky proxy to fetch only the target HTML, maintaining IP stability while maximizing bandwidth cost savings.

When building your custom scraping workflow, how do you balance the scraping success rate with proxy costs? You can check out our Best Proxies for Web Scraping guide to quickly find the proxy solution that fits your business scale.

Proxy setup with Socks5.IO

Socks5.IO’s rotating residential proxies are billed by traffic. Its published plans include $3.50/GB pay as you go, a 75 GB bundle at $1.60/GB and a 20,000 GB bundle at $0.26/GB. Both bundles are valid for 30 days. Generate your proxy credentials in the dashboard with the required country and session settings; use the proxy user credentials, not your dashboard login.

Socks5.IO rotating residential proxy pricing with $3.50/GB pay as you go and 30-day bundles from $1.60/GB to $0.26/GB

For a planning example, assume each fetch uses 2 MB of billable traffic and use decimal units, 1 GB = 1,000 MB. Then 1,000 fetches use 2 GB: $7 at the published $3.50/GB rate, or $3.20 allocated against the 75 GB bundle. But that bundle’s full purchase is 75 × $1.60 = $120, valid for 30 days: $3.20 is a traffic allocation, not the amount you pay to buy the bundle. Allow extra capacity for failed requests and other billable traffic, using the dashboard usage figures to refine the estimate.

Do not estimate script traffic from a browser’s full page weight: this script downloads HTML without loading page assets. Compare a scraper API and proxy workflow using total expenditure per usable result, including minimum purchases and unused capacity.

The official residential proxy session settings show USERNAME_any-number-country-us for a sticky US session. The documented standard duration is 10 minutes, with a new IP assigned after about 60 seconds without a request. Generate the full username in the dashboard and copy it exactly; do not append a second set of session parameters.

Socks5.IO session control documentation for sticky sessions with the USERNAME_any-number-country-us parameter

A rotating session assigns a new residential IP on every request when you add the -f-1 parameter.

Socks5.IO documentation for rotating sessions with the -f-1 parameter and the country-us parameter

Socks5.IO’s IP check tool shows a proxy’s location and network details. The script below also checks its startup exit IP through its own Requests session before fetching product pages. Compare that IP with the location you selected in the dashboard; the proxy’s session settings determine how long it can persist.

Socks5.IO IP check tool panel for testing a SOCKS5, HTTP or HTTPS proxy without changing browser settings

How to scrape Amazon product data with Python, step by step

The example fetches one marketplace, amazon.com, and writes title, raw price text, rating and image URL to CSV, together with collection context. It makes no automatic retries, does not follow redirects and stops on an access challenge or unexpected layout. A 404 is skipped as a missing page; it does not prove that a product is discontinued.

Install and configure

Use Python 3.12 or later. The commands below use Windows PowerShell; create a virtual environment and install Requests with SOCKS support and Beautiful Soup:

powershellpowershell
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install "requests[socks]==2.34.2" "beautifulsoup4==4.15.0" "PySocks==1.7.1"

In Socks5.IO’s dashboard, open Rotating Residential IP → Proxy Setup and select a proxy user, a US location, SOCKS5 and a sticky session. The official authentication instructions describe credential generation. Copy the generated host, port and complete proxy username; do not substitute your dashboard login. Set a complete proxy URL using socks5h://username:password@host:port, URL-encoding reserved characters in the username and password separately. Requests uses socks5h to resolve target hostnames through the proxy, as its SOCKS documentation explains.

Set these environment variables in the terminal that will run the script:

powershellpowershell
$env:PROXY_URL = 'socks5h://ENCODED_PROXY_USERNAME:ENCODED_PROXY_PASSWORD@PROXY_HOST:PROXY_PORT'
$env:SCRAPER_CONTACT = 'YOUR_REAL_CONTACT_EMAIL'
$env:PROXY_COUNTRY = 'US'

Replace every placeholder. PROXY_COUNTRY is a label for the country you requested in the dashboard, not a setting that changes the proxy or verifies its location. The script checks the configuration before making requests and never prints the proxy URL or password.

Save and run the script

Save the following as amazon_products.py:

pythonpython
"""Small, permission-based Amazon HTML example; no challenge bypass or retries."""

import argparse
import csv
import ipaddress
import os
import re
import sys
import time
from datetime import datetime, timezone
from urllib.parse import urlsplit

import requests
from bs4 import BeautifulSoup


def build_session():
    proxy = os.environ.get("PROXY_URL", "").strip()
    contact = os.environ.get("SCRAPER_CONTACT", "").strip()
    try:
        parsed = urlsplit(proxy)
        valid = (
            parsed.scheme == "socks5h" and parsed.hostname and parsed.port
            and parsed.username and parsed.password
            and parsed.path in ("", "/") and not parsed.query and not parsed.fragment
        )
    except ValueError:
        valid = False
    if not valid:
        raise ValueError("Set PROXY_URL to a complete, URL-encoded socks5h proxy URL")
    if not re.fullmatch(r"[^\s@]+@[^\s@]+\.[^\s@]+", contact) or contact.endswith("@example.com"):
        raise ValueError("Set SCRAPER_CONTACT to a real contact email address")
    session = requests.Session()
    # Do not let environment proxies or NO_PROXY override this configuration.
    session.trust_env = False
    session.proxies.update({"http": proxy, "https": proxy})
    session.headers.update({
        "User-Agent": f"price-research/1.0 (contact: {contact})",
        "Accept-Language": "en-US,en;q=0.9",
    })
    return session


def request_page(session, url, label):
    try:
        response = session.get(url, timeout=(10, 30), allow_redirects=False)
    except requests.exceptions.ProxyError:
        print(f"{label}: proxy connection or authentication failed", file=sys.stderr)
        return None
    except requests.exceptions.Timeout:
        print(f"{label}: connection or read timeout", file=sys.stderr)
        return None
    except requests.exceptions.SSLError:
        print(f"{label}: TLS verification failed", file=sys.stderr)
        return None
    except requests.exceptions.RequestException:
        # Exception strings can contain the proxy URL and credentials.
        print(f"{label}: network or client configuration error", file=sys.stderr)
        return None
    return response


def check_exit_ip(session):
    response = request_page(session, "https://api.ipify.org?format=json", "IP check")
    if response is None or response.status_code != 200:
        raise ValueError("Proxy exit IP check failed; no product pages requested")
    try:
        return str(ipaddress.ip_address(response.json()["ip"]))
    except (ValueError, KeyError, TypeError):
        raise ValueError("IP check did not return a valid public-IP response") from None


def parse_product(html):
    soup = BeautifulSoup(html, "html.parser")
    title = soup.select_one("#productTitle")
    if not title or not title.get_text(strip=True):
        return None
    price = soup.select_one(
        "#corePrice_feature_div .a-offscreen, "
        "#corePriceDisplay_desktop_feature_div .a-offscreen"
    )
    rating = soup.select_one("#acrPopover")
    image = soup.select_one("#landingImage")
    return {
        "title": title.get_text(strip=True),
        "price": price.get_text(strip=True) if price else "",
        "rating": rating.get("title", "") if rating else "",
        "image": image.get("src", "") if image else "",
    }


def fetch_product(session, asin):
    response = request_page(session, f"https://www.amazon.com/dp/{asin}", asin)
    if response is None:
        return "stop", None
    status = response.status_code
    if status == 404:
        print(f"{asin}: HTTP 404; page not found, skipping")
        return "missing", None
    if status != 200:
        detail = {
            403: "access denied", 429: "rate limited; no automatic retry",
            503: "service unavailable or access challenge",
        }.get(status, "unexpected response or redirect")
        print(f"{asin}: HTTP {status}; {detail}; stopping", file=sys.stderr)
        return "stop", None
    if re.search(r"captcha|validatecaptcha|automated access|robot check", response.text, re.I):
        print(f"{asin}: possible access challenge; stopping", file=sys.stderr)
        return "stop", None
    product = parse_product(response.text)
    if product is None:
        print(f"{asin}: missing product title; unexpected layout or challenge; stopping", file=sys.stderr)
        return "stop", None
    return "ok", product


def run(session, asins, output, delay=10):
    exit_ip = check_exit_ip(session)
    print(f"Proxy exit IP at start: {exit_ip}")
    fields = [
        "asin", "marketplace", "collected_at_utc", "currency_assumption",
        "requested_proxy_country", "proxy_exit_ip_at_start",
        "title", "price", "rating", "image",
    ]
    written = 0
    # Exclusive creation avoids silently overwriting a previous collection.
    with open(output, "x", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fields)
        writer.writeheader()
        for index, asin in enumerate(asins):
            if index:
                time.sleep(delay)
            status, product = fetch_product(session, asin)
            if status == "stop":
                print(f"Stopped; {written} rows saved to {output}", file=sys.stderr)
                return 1
            if status == "missing":
                continue
            writer.writerow({
                "asin": asin, "marketplace": "amazon.com",
                "collected_at_utc": datetime.now(timezone.utc).isoformat(),
                "currency_assumption": "USD",
                "requested_proxy_country": os.environ.get("PROXY_COUNTRY", "unspecified"),
                "proxy_exit_ip_at_start": exit_ip,
                **product,
            })
            written += 1
            absent = [key for key in ("price", "rating", "image") if not product[key]]
            print(f"{asin}: saved" + (f"; empty fields: {', '.join(absent)}" if absent else ""))
    print(f"Saved {written} rows to {output}")
    return 0 if written else 1


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--asin", nargs="+", required=True, help="Authorized product ASINs")
    parser.add_argument("--output", default="products.csv")
    args = parser.parse_args()
    if any(not re.fullmatch(r"[A-Z0-9]{10}", asin) for asin in args.asin):
        parser.error("Each ASIN must contain exactly 10 uppercase letters or digits")
    try:
        with build_session() as session:
            return run(session, args.asin, args.output)
    except (ValueError, OSError) as error:
        print(f"Configuration or output error: {error}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())

Find the ASIN in the product URL: it is the 10-character identifier after /dp/, or in the Product information section. Replace YOUR_ASIN below with that identifier and run the command from the directory containing the script:

powershellpowershell
.\.venv\Scripts\python.exe amazon_products.py --asin YOUR_ASIN --output products.csv

Use a new output filename for each run; the script refuses to overwrite an existing CSV. It prints the startup exit IP and saves each parsed product as a row. A run with at least one saved row and no stopping error exits with status 0. Compare the title and raw price text with the source page, including the selected variation and offer. Empty fields are reported; a challenge or unexpected response stops the run with status 1 and keeps rows already collected.

To collect a short list, pass multiple ASINs after --asin, separated by spaces. The script waits 10 seconds between product requests.

currency_assumption records USD for this US-store example; it is not detected from the page, and a dollar symbol alone is not proof of currency. requested_proxy_country records your label, while proxy_exit_ip_at_start records the initial check. Verify the actual currency and delivery context before comparing observations.

Common errors

Message or symptom What to check Next step
Configuration error before any request Complete proxy URL, encoded credentials and real contact email Correct the environment variables in the same terminal
Proxy connection or authentication failed Dashboard-generated host, port, proxy user status and available traffic Correct the configuration and repeat the IP check
Connection or read timeout Network reachability and proxy service status Diagnose connectivity before another collection run
HTTP 403, 429, 503 or a challenge Target access rules, rate limits and permitted access route Stop; for 429, respect any Retry-After guidance before considering an authorized later run
Missing product title Challenge page or changed HTML layout Inspect an authorized saved sample and update the parser; do not assume the proxy IP is at fault
Empty price No visible offer, different layout or delivery/variation context Compare against the source page; do not interpret a blank as zero

Scraping Amazon prices

Price tracking needs more context than a number. A product can have different offers, variations, coupons and delivery conditions. Four habits help keep observations comparable:

  • Scope the selector. Many product layouts include the combined price in an a-offscreen element. A page can contain several such elements, so select within the main price container rather than taking the first match anywhere on the page.
  • Record the context. Keep the marketplace, timestamp and location settings with each price. The example labels currency as an assumption; confirm the displayed currency before comparing observations.
  • Do not mix domains. amazon.com, amazon.co.uk and amazon.de differ in markup, language and currency format, so a parser built for dollars can fail on another store.
  • Track missing fields. Empty prices can indicate a changed layout, unavailable offer or access problem. Record and investigate them rather than treating them as a zero price.

A price monitoring proxy workflow also needs consistent delivery location, selected variation and offer type; the small example above does not capture those dimensions automatically.

Keeping an Amazon scraper working

Page layouts can vary by marketplace, product and visit. Keep representative HTML samples for the fields you need, and check the parser against them when you change a selector. Monitor missing prices and titles separately: a valid title with no price can mean an unavailable offer, while a page with no title needs closer inspection.

Do not silently substitute zero for a missing price or another seller’s offer for the selected product’s price. If layout maintenance becomes frequent, compare that work with the cost of an API that maintains its own parser.

FAQs

Public visibility does not itself establish legal permission. Amazon’s Conditions of Use exclude collection of product listings, descriptions and prices, and data-extraction tools, from the ordinary license. Whether a specific project is lawful also depends on its jurisdiction, access method, permissions and data use. Obtain the necessary permission or license, and seek legal advice for a commercial project rather than assuming that logged-out access is unrestricted.

Latest articles

Global proxy network illustration

Plug into the global proxy network — every connection faster and more stable

Start for Free