Complete 2026 Amazon Scraping Guide: Product Data, Prices, Sellers, and More

Amazon is the world's largest marketplace and go-to platform for every e-commerce vendor, especially in the US.

That's why scraping Amazon can provide invaluable data and it's the same reason why scraping it is so difficult...

... but not impossible.

In this guide, we'll scrape simple product pages, product pages with multiple options and numerous variants, and all seller offers from Amazon; unlocking access to millions of Amazon products.

[Plug-and-play codes on our GitHub repo 🧰]

These might help too:

• scrape Amazon search results and sponsored products
• best Amazon scraper APIs
• scrape Amazon reviews
• scrape Amazon best sellers

Does Amazon Allow Scraping?

Yes, scraping Amazon is possible and legal as long as you follow the guidelines and stay away from any login protected personal information.

By respecting these rules and ethical scraping practices, you can gather publicly available data without crossing any laws or regulations, however, if you go into detail, it's not that simple.

Amazon's Web Scraping Policy

Amazon's official Conditions of Use explicitly prohibit "the use of any robot, spider, scraper, or other automated means to access Amazon Services for any purpose."

This applies to their Terms of Service, robots.txt, and every other policy document they publish. Amazon has a legal team that actively pursues scrapers and they won't hesitate to send cease-and-desist letters or take legal action if they catch you scraping at scale.

But here's the nuance: just visiting a website doesn't mean you've agreed to their terms. You didn't sign anything. You didn't click "I agree." Courts in multiple jurisdictions have recognized this distinction.

Legal Considerations

Scraping publicly available data has been recognized as legal by courts around the world. The landmark hiQ Labs v. LinkedIn case in the US established that scraping public data doesn't violate the Computer Fraud and Abuse Act. Similar rulings exist in the EU and other jurisdictions.

The key distinction is public vs. private data:

• Public data (product pages, prices, search results) = generally legal to scrape
• Private data (behind login walls, personal information) = off-limits

Amazon's robots.txt outlines which parts of the site are accessible to automated tools. When scraping Amazon:

• Avoid login-protected content like extended customer reviews—these require authentication and are explicitly restricted.
• Stick to publicly accessible pages like product listings, prices, and search results.

Amazon recently moved extended customer reviews behind login walls. This actually clarifies the boundary: if it requires a login, don't scrape it.

Ethical Guidelines

Scraping ethically means balancing your goals with respect for the website's integrity and policies.

Ethical scraping doesn't just help you avoid potential legal pitfalls; it also fosters a responsible approach to data collection.

Here are a few best practices:

1. Respect Rate Limits: Sending too many requests in a short period can overwhelm Amazon’s servers. Use delays or throttling to mimic real user behavior.
2. Stick to Publicly Available Data: Avoid scraping content that requires login credentials or is marked as off-limits in the robots.txt file.
3. Use Data Responsibly: Whether for analysis or application development, ensure that the data you collect is used in ways that align with Amazon’s guidelines.

To learn more about ethical scraping and the legal landscape, check out this detailed guide on legality of web scraping.

Bypass Amazon AWS WAF

Amazon uses its in-house solution, AWS WAF to protect the platform from bots and scrapers.

Any request you send, whether it's through your Chrome browser or using Python Requests, your IP, headers, and recent activity is analyzed to make sure you're human.

So, how do you make your bot bypass it?

Here are your options, basically:

• Manual methods/in-house solutions: create and maintain a pool of premium proxies and headers to make sure your requests are not flagged.
• Open-source stealth plugins: pick from countless options such as scrapy-fake-useragent + scrapy-rotating-proxies , camoufox + cheap rotating proxies , rebrowser-puppeteer to go through AWS WAF. These would run locally and cause performance and success rate issues as you scaled, though.
• (Method we will also use in this guide) Web scraping APIs: a web scraping API known to handle Amazon persistently such as Scrape.do will handle proxies, headers, and CAPTCHAs for you.

Amazon is not impossible to break for a few scraping requests.

But if you're planning on extracting data from millions of products, you need to think about scalability, as re-using proxies and headers will only get you so far.

Prerequisites

Before we start scraping Amazon, let's set up our environment with the necessary tools.

Install Required Libraries

We'll use two Python libraries for this tutorial:

• Requests: A simple HTTP library that lets us send requests to web servers and receive responses. It handles all the complexities of making HTTP calls behind the scenes.
• BeautifulSoup: A powerful HTML parsing library that makes it easy to extract data from web pages by navigating the document structure.

Install both with a single command:

Grab a Free Scrape.do Token

To bypass Amazon's WAF (Web Application Firewall), we'll route our requests through Scrape.do.

Can you scrape Amazon without Scrape.do? Yes, but it would require significant effort to build a browser-like scraper that won't get caught by Amazon's anti-bot systems. All the parsing code in this guide would still work—the difference is only in how you fetch the pages.

Here's why Scrape.do makes Amazon scraping easier:

• Automatic WAF bypass: No need to manage headers, cookies, or browser fingerprints
• Proxy rotation: Requests are routed through millions of IPs to avoid rate limiting
• CAPTCHA handling: CAPTCHAs are solved automatically when they appear

For even simpler integration, check out Scrape.do's Amazon Scraper API which returns structured JSON data with ZIP Code based geotargeting and language parameters—no parsing required.

Sign up at scrape.do to get your free API token, then you're ready to start.

Scraping Product Data from Amazon (Basic)

Extracting information from an Amazon product page will be our starting point for this tutorial.

From product prices and images to descriptions and ratings, these pages contain data that can be invaluable for market analysis or application development.

For the scope of this step we will be using this product as an example.

Getting 200 OK from Amazon

We'll focus on getting a successful HTTP response from the Amazon servers. By routing our request through Scrape.do's API, we can effortlessly skip Amazon's WAF protection.

This step would normally be quite complex due to Amazon's advanced protection systems, but with Scrape.do we don't need to handle any bypass mechanisms!

After defining our token and the product URL, we can send our first request:

At this point we should be getting a HTTP response stored in our response variable and if we print it into our console it should be looking like this:

HTTP response with the 200 code means our request is successful.

We can access the contents of the response by using;

This will include all of the html contents of the page including any scripts that is available.

If you want; you can print this information on your console to check or even write it into a html file to have a local copy of the product page on your computer.

Our next step will be extracting the information we need from this raw text.

How to Scrape Amazon Product Prices

Price is the most important information about a product, so it will be a nice starting target for us.

For this step we will start using BeautifulSoup because it helps us parse the data we need.

Before starting the extraction process we need to locate the information that is necessary inside the product page we just downloaded. We can either use the response.text that we downloaded in previous step or we can go into the product page and use developer tools to inspect the elements.

You can use F12 to access the developer tools on Google Chrome and press ctrl + shift + c to inspect the element you want.

Or you can click the inspection tool:

Hover over the price details and you will see that the price is divided into whole section and fraction section:

We will use BeautifulSoup to extract price details from both these sections and then put them together:

⚠ Amazon uses different price structures depending on product availability. We need to handle both regular pricing and out-of-stock scenarios, so we'll first see if the item is out of stock and scrape the price only if it isn't.

After running this script we should be getting the product price printed on our console, whether it's available or out of stock.

Price: $28.57 or Price: Out of Stock

Scrape Other Product Details

The following steps will be pretty similar to getting the price information.

We will inspect each of the information that we are insterested using the developer tools and we will try to find an encapsulating html object that holds the complete information.

Then with the help of BeautifulSoup we will locate this information inside the response we are getting.

Product Name

We can see that product name is stored inside a span object with the id productTitle. Again we will access this object with BeautifulSoup and try to print the information inside of it.

We should be getting product name printed on our console.

Product Image

It is time for the product image; we will start with inspecting the element again and find the html object containing the product image.

landingImage is the id of the element that contains the image.

But this time we are interested in the src attribute of the object instead of the text, since image url is stored in this attribute. We can find and access to the src attribute of this element using following:

We should be getting the image url printed on our console!

It is also possible to download and save this images into your drive but for the scope of this tutorial we will stop here and store the information about product images as urls.

Product ASIN

The ASIN (Amazon Standard Identification Number) is a unique identifier for each product. We can extract this directly from the URL, which is useful for database storage and referencing.

This will give us:

Product Rating

And finally the product rating.

Our first step is again to inspect:

As we can see product rating element is not encapsulated directly under a tag that we can refer to. a-size-medium a-color-base classes are generic classes and will return other objects if we tried to use it.

div object with the AverageCustomerReviews class is something we can easily access and contains all of the information we need but also has information that we don't need.

We will try to get this information and strip the part we are interested.

This will return the following:

This string contains the rating twice, also we don't need to specify it is out 5.

So we are going to split this string and get a single rating score. Let's update our code as follows:

Now we get this:

Export to CSV

To make your scraped data actionable and be able to easily scale this up to a thousand products, it’s essential to save it in a structured data format.

So we will export it into CSV which is the most basic format.

You can use libraries like pandas to easily save your data frames into csv files but in this tutorial we will do it without a help of a library, using Python's built-in module.

Let's also use two additional products to make our code loop through URLs.

Here's the final code:

And voila, information about these 3 products should be saved into our CSV file.

Here's our output:

One API Call, More Data

If you'd rather skip the HTML parsing entirely, Scrape.do's Amazon Scraper API has a dedicated PDP (Product Detail Page) endpoint that returns structured JSON.

One request, all the data:

Sample response:

No parsing required—just pass the ASIN and get back clean, structured product data with pricing, ratings, images, and technical specs.

Scrape All Color,Size,Model Variations of an Amazon Product (Advanced)

Many Amazon products don’t have a single, static price.

The price changes with the option you choose: color, size, style, model and more.

If you only scrape the default page, you’ll miss most of the catalog, so the right way is to discover every available variation and visit each variation’s dedicated URL to read its own price and selected options.

What we’re building below is a reliable (and maybe overengineered) system that:

• Finds all variation dimensions on the base product page (color, size, style, etc.)
• Walks through every valid option combination without duplication
• Reads the selected options on each visited page and grabs prices and product names
• Writes everything into a clean CSV

I'm probably picking the most complicated target page possible for this code, but we need our code to work in complex scenarios, so it'll be good practice :)

We'll scrape all colors, storage sizes, and service providers for Apple iPhone 14 Plus here:

Extract All Available Variations

We’ll begin by grabbing the base product page and mapping out the full set of variation dimensions and their options.

First, we build the API request through Scrape.do:

Scrape.do returns the fully-rendered HTML and handles the heavy lifting (WAFs, geo, headers).

Then, we'll reuse the exact same product name and price logic from previous section: if the out-of-stock container exists, we mark it as such; otherwise we stitch the whole and fractional price.

Then, we'll extract all dimension and option names from the select menus.

Amazon exposes variation groups in “inline-twister-row-*” containers. Each option usually has:

• A display label from a swatch title, image alt, or button text
• An ASIN we can navigate to (the key to get the correct price for that option)

We skip options that are initially unavailable to avoid dead ends.

We then also set up a sensible traversal order and CSV headers so downstream steps are clean and deterministic.

Scrape All Product Variations One by One

Next, we’ll recursively walk through the option tree.

For each option, we load its dedicated product page (using the option’s ASIN) and capture both the selected options and the correct price.

Every time we navigate to an option’s ASIN, the page’s available options can change (e.g., some sizes are only available for certain colors).

We always read the page’s current dimensions before deciding what to do next, and then record selected options and price from the current page:

And at a terminal node, we compile a single output row that includes:

• The ASIN we visited (unique identifier for the variation)
• The product title
• The selected option values for each dimension
• The price shown on that page

And then, we repeat it. Move along to the next dimension and visit each option once:

We use a simple depth-first traversal.

The scraped set ensures we never visit the same ASIN twice.

For the first dimension, we print progress so we'll be able to track progress too.

Run Code and Export

We start the crawl from the ASIN present in the base URL and write rows as we complete leaves.

Headers are constructed dynamically from discovered dimensions so your CSV is always aligned with each product’s real variation model:

And finally, we're exporting all results to a CSV:

When you run the complete code, it'll start printing progress on the terminal:

It's easier said than done, but that's it! And here's what your CSV file will look like:

A clean, machine-readable CSV with one row per unique variation, each row tied to the actual ASIN, the exact selected options, and the price shown for that combination.

How to Scrape Seller Prices on Amazon

Most Amazon products have multiple sellers offering the same item at different prices, conditions, and shipping options.

This data is great for:

• Price comparison and arbitrage
• Identifying the Buy Box winner
• Monitoring competitor pricing
• Tracking seller reputation over time

And the good news is that Amazon exposes all seller offers through a hidden AJAX endpoint that returns structured HTML, so no heavy WAF bypass needed.

Finding the Seller Offers Endpoint

When you click "Other Sellers on Amazon" or the seller count link on a product page, Amazon loads seller data via an AJAX call.

Open your browser's Network tab (F12 → Network), click on the sellers section, and you'll see a request to:

This endpoint returns a semi-structured HTML response with all active offers for that product—much easier to parse than the full product page.

Build the Request

We'll use Scrape.do to fetch the seller offers page. The endpoint is lightweight and will sometimes allow access with simple HTTP calls, but routing through Scrape.do ensures consistent access:

Helper Functions

Before parsing, we'll create two helper functions to keep our extraction code clean:

get_text safely extracts and normalizes text from an element, while find_match pulls specific values using regex patterns.

Parse Seller Offers

Each seller offer lives in a container with the aod-offer-soldBy div. We'll loop through all of them and traverse up to find the parent container that holds the price:

Extract the price by combining whole and fractional parts—same pattern we used for product pages:

Get the seller name from the link to their storefront. If no link exists, it's Amazon selling directly:

Extract seller reputation data including star rating, total ratings, and positive feedback percentage:

Get fulfillment details where it ships from and the item condition (New, Used, Refurbished, etc.):

Build the offer object and add it to our list:

Export to CSV

Finally, add the export logic to save all results to a CSV:

Running this on a MacBook Air listing returns sellers like Amazon, Adorama, and third-party resellers—each with their price, condition, rating, and fulfillment details:

Now you have structured seller data ready for your workflows.

Or The Easy Way

Want structured JSON instead of parsing HTML? The Amazon Scraper API has an offer-listing endpoint that returns all seller offers in a clean format:

Sample response:

Every seller offer with pricing, condition, fulfillment details, and Buy Box status—no parsing needed.

Next Steps

You've now got everything you need to scrape product data, all variations, and seller offers from Amazon.

But there's more data to extract. Here's where to go next:

What You'll Extract	Guide
Search results, sponsored products, and related searches	Scrape Amazon Search Results
Top 100 best-selling products by category with rankings	Scrape Amazon Best Sellers
Customer reviews and ratings at scale	Scrape Amazon Reviews

Each guide follows the same pattern: find the right endpoint, parse the HTML, and export to CSV.

And if you want to skip the parsing entirely, Scrape.do's Amazon Scraper API returns structured JSON for products, search results, and seller offers—with ZIP code geotargeting built in.

Start scraping today with 1000 free credits.

Frequently Asked Questions

Can you scrape Amazon for prices?

Answering this question from two different angles; yes, it is legal to scrape product prices on Amazon because they're public data and yes, even a beginner developer can easily scrape them following this guide using Python.

How do you retrieve data from Amazon?

You can easily retrieve data from Amazon in 3 steps:

1. Use a web scraping API or a stealth plugin to bypass Amazon's firewall,
2. Write a code in your preferred programming language that retrieves HTML responses and parses the data you want (more info in this guide)
3. Input your target URLs and automate the process using workflows.

Is Amazon easy to scrape?

Amazon is not easy to scrape at all. If you're trying to scrape without an existing scraping operation to handle anti-bot restrictions and proxies you'll instantly get blocked. If you use a scraping API that is known to handle Amazon's WAF, however, it can become quite simple to extract data from Amazon.

Does Amazon have anti-scraping?

Yes, Amazon uses AWS WAF as it's firewall to block all bots including scrapers. It analyzes your IP, headers, and activity to make sure you're a regular human browsing the website; and if you're not you're blocked instantly.