Best Web Scraping APIs for Amazon: July 2026 Benchmark

Scrapfly is the best web scraping API for Amazon, with a 96% success rate across 8 web scraping APIs benchmarked against live Amazon pages in July 2026. 4 of the 8 cleared Amazon reliably enough to recommend.

Amazon is protected by AWS WAF running on CloudFront, plus its own layered rate limiting and bot heuristics, so most scraping APIs either fail on the harder pages or pay for it in speed and cost. The benchmark is refreshed twice a month, with no affiliate links and no sponsors.

Ranked by live Amazon success rate, best first:

1. 🥇 Scrapfly: 96% success on Amazon
2. 🥈 Firecrawl: 95% success on Amazon
3. 🥉 Scrapingdog: 93% success on Amazon

All 7 web scraping APIs for Amazon, ranked

#	Service	Success	Speed	Cost/1k		Code
1 🥇	Scrapfly	96%	8.9s	$3.32	(237) ★ 4.9	code
2 🥈	Firecrawl	95%	5.8s	$6.33	n/a	code
3 🥉	Scrapingdog	93%	3.7s	$0.2	n/a	code
4	Scraperapi	92%	5.2s	$2.45	(62) ★ 4.6	code
5	WebScrapingAPI	64%	25.1s	$2.71	n/a	code
6	Scrapingbee	43%	6.3s	$0.32	(137) ★ 4.9	code
7	Scrapingant	15%	22.6s	$1.9	n/a	code

Data range Jul 31 to Aug 14

Ranking history: web scraping APIs for Amazon over time

The 7 web scraping APIs for Amazon, reviewed

1. Scrapfly: 96% success on Amazon

Amazon serves different defenses to different pages. Product pages are mostly static HTML with the data in embedded markup, while search, deals, and high frequency endpoints lean on AWS WAF challenges and aggressive rate limiting. Scrapfly cleared 96% here by routing through residential IPs and generating a genuine browser fingerprint, so it clears AWS WAF challenges. Because it only bills for successful requests, the soft blocked empty responses Amazon returns don't quietly run up the cost.

At $3.32 per 1,000 successful requests and 8.9s average response time, the figures are strong for an API clearing Amazon at this rate. The 96% success rate is the headline, and the ranking history above shows how that rate has held across previous runs.

Pros:

• Highest success rate in the Amazon Products benchmark this run
• Only charges for successful scrapes, so soft blocked empty responses cost nothing
• One asp flag plus residential proxies handles Amazon with little tuning
• First class SDKs for Python, TypeScript, Go, and Rust, plus a Scrapy extension

Cons:

• Credit cost per request rises once ASP, JavaScript rendering, or residential proxies are enabled
• The entry (Discovery) plan caps concurrency at 5, so high volume catalog crawls need a higher tier
• The free tier is a single batch of 1,000 credits, enough to prototype but not to benchmark at volume

2. Firecrawl: 95% success on Amazon

Firecrawl's draw on Amazon is its output format. It returns structured markdown rather than raw HTML, so a pipeline feeding an LLM or RAG system skips the parsing and cleaning step on Amazon's dense product markup. Rendering a full browser on every page and generating that markdown carries a cost and latency premium over lighter, HTTP based options, so that saving has to be worth the premium for your use case. On Amazon it cleared 95% this run.

Pros:

• Returns markdown built for LLM pipelines, saving a parsing step on Amazon's product HTML
• Runs a real browser, which helps on Amazon's pages that require JavaScript rendering

Cons:

• Cost is the top user complaint in reviews
• Renders a full browser on every page, which adds latency
• Overkill if you only need structured fields rather than clean text

3. Scrapingdog: 93% success on Amazon

Scrapingdog offers low entry pricing and a simple API, without first party SDKs. Amazon's WAF and rate limiting apply across a sustained crawl rather than to single requests. On Amazon it cleared 93% this run.

Pros:

• Low entry pricing
• Simple API

Cons:

• No first party SDKs
• Reviewers frequently cite slow, email only support with no live chat option

4. Scraperapi: 92% success on Amazon

Scraperapi is built around a fast request path. When it clears a request it tends to return quickly, which suits latency sensitive Amazon lookups that can absorb retries. It also ships a dedicated Amazon structured data endpoint, which helps on product pages. Our Amazon benchmark covers product pages, and search and high frequency endpoints are more heavily rate limited, so results there may differ. On Amazon it cleared 92% this run.

Pros:

• Fast when it clears, with a dedicated Amazon structured data endpoint
• Broad language SDK support and simple integration

Cons:

• Login required flows and form filling are off limits
• Geotargeting is gated by plan (US and EU only until the Business tier)

5. WebScrapingAPI: 64% success on Amazon

WebScrapingAPI covers a broad range of language SDKs behind a simple REST interface, so it drops into most stacks without a client library, and it supports async and batch submission for queued jobs. The scorecard carries this run's speed and cost. On Amazon it cleared 64% this run.

Pros:

• Broad language SDK range behind a simple REST interface
• Async and batch submission for queued jobs

Cons:

• Amazon's soft blocked and empty 200 responses make it easy to keep paying unless you check content
• Support tickets often go unanswered for days, per user reviews

6. Scrapingbee: 43% success on Amazon

Scrapingbee is fast and cheap per request, with JavaScript rendering for lighter targets. Amazon leans on WAF challenges and rate limiting, and credits burn quickly once JS rendering and premium proxies are on. On Amazon it cleared 43% this run.

Pros:

• Fast response times
• Low sticker cost per request on lighter Amazon product pages

Cons:

• Amazon's WAF and rate limiting penalize an HTTP first approach
• Credits burn quickly once JavaScript rendering or premium proxies are enabled
• No plan tier between the small and large options

7. Scrapingant: 15% success on Amazon

Scrapingant bundles JavaScript rendering and session support at a low entry price, with a smaller feature surface than the larger providers. On Amazon it cleared 15% this run.

Pros:

• Low sticker price
• JavaScript rendering included

Cons:

• Smaller feature surface and fewer integration options than the larger providers
• Small provider with a thin public track record

About scraping Amazon

Amazon is the largest ecommerce catalog on the web, and the data people scrape from it is mostly commercial. That means product titles, prices, availability, Buy Box and seller info, ratings and review counts, search result rankings, and category and deals listings. Most of these live on product detail pages (the /dp/{ASIN} URLs), search pages, and seller storefronts.

Amazon product pages are largely server rendered HTML, so a plain HTTP request often returns the core fields without a headless browser. The catch is where the data sits. Prices, Buy Box state, and variation data are spread across embedded markup and inline JSON rather than one clean object, and some blocks load through secondary requests. Search, deals, and other high frequency endpoints are more dynamic and far more rate limited, so a headless browser and residential proxies matter more there than on a single product page.

Amazon is protected by AWS WAF running on its CloudFront CDN, alongside its own rate limiting and bot heuristics. See AWS's Bot Control documentation for how that protection detects bots. The practical detail for scraping Amazon is that blocks often come back as a CAPTCHA page or an empty 200 rather than a hard error, so success has to be measured on response content, not status codes.

from parsel import Selector

# install using `pip install scrapfly-sdk`
from scrapfly import ScrapflyClient, ScrapeConfig, ScrapeApiResponse

# create an API client instance
client = ScrapflyClient(key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.scrape(ScrapeConfig(
            url=url,
            headers=headers,
            asp=True,
            render_js=render_js or True,
            cache=False,
            cache_ttl=900,
            country=country or 'us',
            rendering_stage='domcontentloaded',
            method='GET',
    ))
    return api_result.selector

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# install using `pip install firecrawl-py`
from firecrawl import Firecrawl

# create an API client instance
client = Firecrawl(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.scrape(
        url=url,
        headers=headers or {},
        formats=['rawHtml'],
        only_main_content=False,
        skip_tls_verification=False,
        timeout=150000,
        store_in_cache=False,
        max_age=900,
    )
    assert api_result.raw_html, "firecrawl returned no html for this page"
    return Selector(api_result.raw_html)

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# scrapingdog has no integration but we can use httpx
# install using `pip install httpx`
import httpx

# create an API client instance
client = httpx.Client(timeout=180)

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    params = {
        "api_key": "YOUR API KEY",
        "url": url,
        "domain": 'com',
        "asin": 'B0DCH8VDXF',
        "country": country or 'us',
    }
    api_result = client.get(
        'https://api.scrapingdog.com/amazon/product',
        params=params,
    )
    assert api_result.status_code == 200, api_result.text
    # this dedicated endpoint answers with structured JSON rather than page HTML,
    # so read the fields straight off api_result.json() instead of the selector below
    return Selector(api_result.text, type="html")

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# install using `pip install scraperapi-sdk`
from scraperapi_sdk import ScraperAPIClient

# create an API client instance
client = ScraperAPIClient(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.make_request(
        url=url,
        headers=headers,
        params={
            "render": False,
        },
        method='GET',
    )
    assert api_result.ok, api_result.text
    return Selector(api_result.text)

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# webscrapingapi has a Python SDK but it's not great, use httpx instead:
# `pip install httpx`
import httpx

# create an API client instance
client = httpx.Client(timeout=180)

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        "https://api.webscrapingapi.com/v2",  # the target url is passed as a parameter below
        headers=headers,
        params={
            "url": url,
            "api_key": "YOUR API KEY",  # NOTE: add your API KEY here!
            "timeout": 60_000,
        },
    )
    assert api_result.status_code == 200, api_result.reason_phrase
    return Selector(api_result.text)

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# install using `pip install scrapingbee`
from scrapingbee import ScrapingBeeClient

# create an API client instance
client = ScrapingBeeClient(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        url,
        headers=headers,
        params={
            "json_response": True,
            "transparent_status_code": True,
        }
    )
    assert api_result.ok, api_result.text
    data = api_result.json()
    return Selector(data['body'])

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# install using `pip install scrapingant-client`
from scrapingant_client import ScrapingAntClient

# create an API client instance
client = ScrapingAntClient(token="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.general_request(
        url,
        json=True,
        proxy_type='residential',
        method='GET',
    )
    # the scrapingant client returns its own Response object: content holds the page
    assert api_result.status_code == 200, api_result.text
    return Selector(api_result.content)

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

from parsel import Selector

# install using `pip install zenrows`
from zenrows import ZenRowsClient

# create an API client instance
client = ZenRowsClient(apikey="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        url,
        headers=headers,
        params={
        }
    )
    # zenrows answers with the page HTML; "json_response" is only accepted with js_render on
    assert api_result.ok, api_result.text
    return Selector(api_result.text)

url = "https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/"
selector = scrape(url)
data = {
    "url": url,
    "name": selector.css("#productTitle::text").get("").strip(),
    "asin": selector.css("input[name=ASIN]::attr(value)").get("").strip(),
    "price": selector.css('span.a-price ::text').get(),
    # ...
}
from pprint import pprint
pprint(data)

  {
  'asin': 'B0B92489PD',
  'name': 'Amazon Kindle – The lightest and most compact Kindle, with extended '
  'battery life, adjustable front light, and 16 GB storage – Without '
  'Lockscreen Ads – Black',
  'price': '$99.99',
  'url': 'https://www.amazon.com/kindle-the-lightest-and-most-compact-kindle/dp/B0B92489PD/'
  }

How to choose a web scraping API for Amazon

Start by deciding which Amazon pages you need, because that changes the answer. For product detail scraping at low volume, most of the reliable APIs in the table work and cost is the deciding factor. For large product page crawls, narrow to the APIs still clearing Amazon at the top of the ranking and choose within that set. Our benchmark covers product pages, so treat search and deals endpoints, which are more heavily rate limited, as untested.

• Reliability first. Scrapfly leads the current Amazon ranking, which makes it the default starting point for production product page crawls. The ranking history shows its track record.
• Value. Among the APIs still clearing Amazon, sort by cost per successful request. The cheapest sticker price is rarely the cheapest per usable Amazon page.
• Speed. If you're doing latency sensitive product lookups rather than bulk crawls, pick the fastest option that still clears Amazon reliably.

The key principle is to judge on cost per successful request, not sticker price. Amazon's soft blocked responses and CAPTCHA pages return a 200, so a cheap API can look like it's working while delivering empty pages, which makes its real cost per usable result far higher than the rate card suggests.

How we benchmark web scraping APIs for Amazon

We independently benchmark 8 web scraping APIs against live Amazon pages, 1,000+ requests per service, twice a month. Every API is tested against the same Amazon URLs at the same time, and cost is measured per 1,000 successful requests on entry plan pricing. We pay for the plans ourselves. No affiliate links. No sponsors. Just data.

8 APIs · 1,000+ requests each · twice a month · no affiliate links, no sponsors

Benchmarking Amazon has one wrinkle worth knowing about. Success is measured on response content, not HTTP status codes. Amazon's CAPTCHA and soft blocked responses return a 200, so a test that only checked for a 200 would overstate results. We verify that responses contain the expected product data before counting them as successful. Every provider is tested against the same URLs in the same run, so the numbers stay comparable. Latest data: Jul 31 to Aug 14, 2026.

Frequently asked questions about scraping Amazon

Is it legal to scrape Amazon?

Scraping publicly available Amazon data such as prices and product details is generally treated as lower risk than scraping data behind a login, but Amazon's Terms of Service prohibit automated access, and personal data (like reviewer profiles) can fall under privacy laws. Legality depends on what you collect, where you operate, and how you use the data, so treat this as general information rather than legal advice and check your own situation.

What's the cheapest API that works on Amazon?

Sort the ranked table by cost per successful request and read down to the first provider still clearing Amazon this run. That's the cheapest option that actually delivers. Lower priced APIs further down often fail too many requests for their sticker price to be meaningful, and Amazon's soft blocking hides those failures unless you check response content.

Do I need a headless browser to scrape Amazon?

Not always. Amazon product pages are mostly server rendered, so an HTTP request with good proxies often returns the core fields. Search, deals, and high frequency pages are more dynamic and much more rate limited, so a headless browser plus residential proxies helps most there. The APIs at the top of the ranking handle this for you.

Why do some APIs score low on Amazon?

Because Amazon's AWS WAF, rate limiting, and CAPTCHA challenges block clients they don't trust across a sustained crawl. A request based tool may return 200 responses that are actually CAPTCHA or empty pages, and since we score on response content, those count as failures rather than successes.

How often is this benchmark updated?

Twice a month against the same live Amazon targets, 1,000+ requests per API each run. We publish after validating the run and checking failures for configuration or detection errors.

Conclusion

Amazon is one of the more forgiving targets on the easy pages and one of the harder ones on search and high frequency endpoints, so the right web scraping API depends on which Amazon data you need. For production product page crawls, start with Scrapfly, the highest success rate in the current run. For cost or speed on lighter product page jobs, choose among the providers still clearing Amazon this run.

Whatever you pick, verify results on response content rather than status codes, because Amazon's CAPTCHA and soft blocked responses both return a 200. The benchmark refreshes twice a month, so check the live Amazon results before committing.

Protected by: AWS WAF  ·  Other ecommerce targets: Walmart · Etsy  ·  Hub: All target benchmarks