How to Bypass Amazon CAPTCHA: 2025 Guide

In this blog post, you will see:

• What Amazon CAPTCHA is and how it works
• Three different approaches to bypassing it
• A complete comparison of these techniques

Let’s get started!

Amazon CAPTCHA: Introduction

Before learning how to bypass it, understand what Amazon CAPTCHA is and why it appears on certain pages.

Definition

Amazon CAPTCHA is an anti-bot measure that appears when visiting Amazon pages with an automation script or performing automated interactions on the site. In most cases, it appears as a simple text-based CAPTCHA, requiring you to enter the characters displayed on the screen:

The challenge above may seem simple, but it is enough to stop most e-commerce web scraping scripts. The good news is that it is not the most advanced CAPTCHA on the market, and there are definitely ways to bypass it.

When It Is Shown

Here is the tricky part… Amazon CAPTCHA does not appear under a fixed set of scenarios or browser configurations. Sometimes, you might encounter it, and other times, you will not.

Based on our tests, the most common scenarios that trigger the CAPTCHA when using automation tools like Selenium, Puppeteer, and Playwright include:

1. Visiting an Amazon product page directly
2. Performing an automated search
3. Attempting to log in or sign up

Still, it is important to note that none of these actions guarantee a CAPTCHA challenge. While you may think that behavior is a good thing, it is actually not! You may be tricked into thinking that your Amazon scraper is working perfectly—only it suddenly starts getting blocked for no apparent reason.

For example, a simple Selenium script like the one below may work without issues, or it may trigger a CAPTCHA:

# pip install selenium

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

# Configure the browser to launch in headless mode
options = Options()
options.add_argument("--headless")
# Initialize the WebDriver to control Chrome
driver = webdriver.Chrome(service=Service(),options=options)

# Connect to the target page (Amazon Kindle product page)
driver.get("https://www.amazon.com/Amazon-Kindle/dp/B0CNV9F72P")

# Take a screenshot of the entire page
driver.save_screenshot("product-page.png")

# Additional scraping logic...

# Release the driver resources
driver.quit()

On successful runs, the script will produce this screenshot:

Instead, on unsuccessful runs, it will produce:

The unpredictable nature of the CAPTCHA appearance makes it challenging to develop a reliable automation logic that consistently triggers the challenge. Because of that, it is also hard to study it. Luckily, that does not mean bypassing that CAPTCHA is impossible.

Time to learn how!

Bypassing the Amazon CAPTCHA: 3 Techniques

In this chapter, you will explore three different approaches to tackling the Amazon CAPTCHA:

• Using a stealth browser
• Using AI
• Using a CAPTCHA solver

For other methods, see our guide on how to bypass CAPTCHAs in Python.

Let’s dive in!

Approach #1: Using a Stealth Browser

How often have you encountered a CAPTCHA while browsing Amazon? Chances are, you have rarely seen one—or never at all. This suggests that real human users are not significantly affected by Amazon’s anti-bot and anti-scraping systems.

As in most scenarios, prevention is better than mitigation. The goal here is not to try to solve the CAPTCHA but to avoid triggering it altogether. How? By configuring your browser automation logic to mimic a real human user as closely as possible when interacting with Amazon’s web pages.

The goal can be achieved by using browsers with stealth plugins that modify automation-related browser settings to prevent leaks and reduce bot detection. Some popular tools for this purpose include:

• SeleniumBase: A Python-based automation framework with built-in stealth capabilities to bypass bot detection in Selenium.
• Playwright Stealth: A Playwright Extra plugin that modifies browser settings to evade detection by anti-bot systems.
• Puppeteer Stealth: A Puppeteer Extra plugin that tweaks browser fingerprints to appear more human-like.
• undetected-chromedriver: A patched Selenium WebDriver that helps bypass detection by anti-bot mechanisms.

In this section, we will focus on SeleniumBase, as it works perfectly with Python. Anyway, you can easily use any of the other options.

To install SeleniumBase, run the following command:

pip install seleniumbase

Then, you can modify the previous Selenium script to use SeleniumBase as below:

from seleniumbase import Driver  

# Initialize the SeleniumBase driver
driver = Driver(uc=True)  # Enables stealth mode  

# Connect to the target Amazon page  
driver.get("https://www.amazon.com/Amazon-Kindle/dp/B0CNV9F72P")  

# Take a screenshot of the entire page  
driver.save_screenshot("product-page.png")  

# Additional scraping logic...  

# Release the driver resources  
driver.quit()

Great! The chances of encountering Amazon CAPTCHAs have been significantly reduced.

Approach #2: Solving It with AI

If you look at a collection of Amazon CAPTCHAs, it is hard to believe AI would not be able to solve them:

After all, basic text recognition challenges seem outdated compared to the more advanced and complex CAPTCHAs found in today’s market:

So, the idea here is to:

1. Take a screenshot of the CAPTCHA page
2. Feed it to ChatGPT or any other AI model
3. Get the AI’s response and use it to solve the CAPTCHA

If you inspect the CAPTCHA HTML, you will see that the text input field can be selected with the .a-span12 CSS selector. Given that information, we can bypass Amazon CAPTCHA using AI with the following approach:

import os
import time
import base64
from openai import OpenAI
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

def solve_amazon_captcha(driver, timeout=5):
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    captcha_elements = driver.find_elements(By.CSS_SELECTOR, "a-span12")

    # If the CAPTCHA has been detected
    if len(captcha_elements) > 0:
        print("CAPTCHA detected!")

        # Take a screenshot of the CAPTCHA page
        driver.maximize_window()
        screenshot_path = "captcha.png"
        driver.save_screenshot(screenshot_path)

        print("Attempting to solve the CAPTCHA...")

        # Feed the screenshot to the AI for CAPTCHA solving
        base64_image = encode_image(screenshot_path)
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "Extract the text from this CAPTCHA. Return only the text."},
                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}},
                    ],
                }
            ],
        )

        # Get the CAPTCHA text
        captcha_text = response.choices[0].message.content.strip()

        # Select teh CAPTCHA input text and fill it out
        # with the AI generated text
        input_element = captcha_elements[0]
        input_element.send_keys(captcha_text, Keys.ENTER)

        print("CAPTCHA solved!")
        print(f"Wait up to {timeout} seconds for page reload...")

        # Wait up to 5 seconds for a page reload
        time.sleep(timeout)

To make the solve_amazon_captcha() function work, install the openai dependency:

pip install openai

Also, set your OpenAI API key as a global environment variable named OPENAI_API_KEY.

This is how you can call the AI-powered CAPTCHA solving function:

driver = webdriver.Chrome()
driver.get("https://www.amazon.com/Amazon-Kindle/dp/B0CNV9F72P")

solve_amazon_captcha(driver)

driver.quit()

Now, your script will solve the CAPTCHA as a human user would.

For a similar approach using Gemini, check out the Genaptcha project on GitHub.

Approach #3: Integrate a CAPTCHA Solver

To achieve the highest accuracy while minimizing calls to AI models—which can be costly due to token consumption because of images, the two solutions mentioned earlier should be combined to:

1. Reduce the frequency of CAPTCHAs on Amazon
2. Solve them only when they do appear

However, the hybrid approach comes with its own challenges:

1. Additional dependencies: You need a stealth browser automation tool, the OpenAI client, and proper environment configurations.
2. Instability: Stealth plugins may work today but become ineffective tomorrow due to the ongoing battle between bot developers and anti-bot solutions. For that reason, keeping your libraries updated is essential. Additionally, LLM models sometimes produce inconsistent results, which can introduce an additional problem. Also, AI struggles with solving more complex CAPTCHAs, which Amazon is likely to adopt in the near future.
3. Retry logic required: To ensure the CAPTCHA is actually solved, you need to implement a retry mechanism in case the AI fails.
4. Slowness: AI introduces significant processing delays. Plus, waiting for the CAPTCHA to appear and disappear further slows down the automation/scraping process.
5. Maintenance overhead: You are responsible for ensuring all chosen technologies are properly configured and continue to function over time.

Wouldn’t it be easier to just use a CAPTCHA solver? Absolutely, especially if this functionality is built directly into the headless browser controlled by the browser automation tool of your choice.

That is exactly the experience delivered by Scraping Browser. It is a cloud-based browser optimized for web scraping, designed for maximum performance while eliminating the need to manage infrastructure. This specialized browser features IP rotation, automatic retries, advanced anti-bot bypass mechanisms, and—of course—built-in CAPTCHA solving capabilities.

See how to easily integrate it with Selenium, Playwright, and Puppeteer just like any other browser in our docs.

Best Way to Crack the Amazon CAPTCHA

This is a recap of the Amazon CAPTCHA techniques explored in this article:

Below is a summary of their strengths and weaknesses.

Approach #1: Using a Stealth Browser

👍 Pros:

• Free and open-source

👎 Cons:

• CAPTCHA evasion, not bypass
• Relies on patched browsers, which can be unstable
• Requires ongoing maintenance

Approach #2: Solving It with AI

👍 Pros:

• Can effectively solve text-based CAPTCHAs

👎 Cons:

• Inconsistent results and ineffective against complex CAPTCHAs
• Detecting the CAPTCHA on the page can be tricky
• AI calls come with a cost

Approach #3: Integrate a CAPTCHA Solver

👍 Pros:

• Highly effective
• Works seamlessly with any browser automation tool or HTTP client
• No need for retry logic, browser configuration, or other manual work

👎 Cons:

• Premium service

Conclusion

In this blog post, you learned why Amazon might stop you with a CAPTCHA and how to handle it in your scraping script. Unfortunately, CAPTCHA appearances are inconsistent, making it difficult to study. Fortunately, there are some techniques to avoid or bypass CAPTCHAs, and here we explore the three most useful ones.

As we discussed, the most effective approach is using Bright Data’s Scraping Browser, which comes with a built-in CAPTCHA solver and integrates seamlessly with Selenium, Playwright, and Puppeteer.

If you are looking for an even simpler solution, consider our other options:

• Amazon CAPTCHA Solver: A dedicated CAPTCHA Solver for Amazon backed by our Web Unlocker.
• Amazon Scraper: A scraping endpoint specifically designed for Amazon pages. Just call it and get the data you need, already parsed in the format you prefer.
• Amazon Datasets: Ready-to-use datasets containing the data you are interested in. No scraping required.

Create a free Bright Data account today and explore our scraping solutions and datasets with a free trial.