Como Evitar Banimentos de IP da Amazon ao Fazer Scraping

Understanding Amazon's IP Ban System

Amazon operates one of the most sophisticated anti-bot systems on the internet. When your IP addresses get banned, you lose access to product data that drives your pricing, research, and competitive intelligence operations. Understanding how Amazon detects and bans IPs is the first step to preventing it.

Amazon does not simply block individual IPs — it builds behavioral profiles. A single suspicious IP might trigger soft blocks (CAPTCHAs), while persistent violations lead to hard blocks (complete access denial). The system tracks patterns across IP ranges, so getting one IP banned can increase scrutiny on neighboring addresses. For a comprehensive understanding of detection methods, see our guide on how anti-bot systems detect proxies.

How Amazon Detects Automated Traffic

Amazon's detection operates on multiple layers simultaneously.

Request-Level Detection

Signal	What Amazon Checks	Risk Level
TLS Fingerprint	TLS handshake matches known bot libraries (Python requests, curl)	High
Header Order	HTTP headers sent in non-browser order	Medium
Missing Headers	Absence of Accept-Language, Accept-Encoding, etc.	High
User-Agent	Outdated, invalid, or known-bot User-Agent strings	High
Cookie Handling	Not accepting or returning session cookies	Medium

Behavioral Detection

Pattern	Description	Risk Level
Fixed intervals	Requests arriving at exact intervals (every 5.0 seconds)	High
Sequential crawling	Visiting ASINs in numerical or alphabetical order	High
No navigation path	Jumping directly to product pages without browsing	Medium
High request volume	Hundreds of requests per minute from one IP	Critical
No JavaScript execution	Pages loaded without executing JavaScript	Medium

IP-Level Detection

Amazon maintains databases of datacenter IP ranges and known proxy providers. Datacenter IPs face immediate heightened scrutiny regardless of behavior. Residential IPs start with higher trust because they share pools with real Amazon shoppers.

Types of Amazon Blocks

Understanding the different block types helps you respond appropriately.

Soft Blocks (CAPTCHA)

The most common response. Amazon serves a CAPTCHA page instead of product data. This is a warning — continue from the same IP and you will escalate to a hard block. When you receive a CAPTCHA, back off immediately and switch to a new IP.

Hard Blocks (503/403 Errors)

Complete denial of access, typically returning HTTP 503 or 403 status codes. Hard blocks can last hours to days for a specific IP. Once hard-blocked, that IP is effectively unusable for Amazon until the block expires.

Content Manipulation

Amazon sometimes serves different content to suspected bots — incorrect prices, missing reviews, or incomplete product data. This is harder to detect because you receive a 200 response. Validate your scraped data against known values to catch this.

Key takeaway: CAPTCHAs are warning signals, not just obstacles. Treat every CAPTCHA as an indicator that your current approach needs adjustment.

Prevention Strategies

1. Use Residential Proxies

This is the most impactful change you can make. Residential proxies use IP addresses assigned to real internet subscribers, making your requests indistinguishable from genuine shoppers. ProxyHat's residential proxy pool covers 195+ countries with millions of IPs.

# ProxyHat residential proxy with geo-targeting
http://USERNAME-country-US:PASSWORD@gate.proxyhat.com:8080
# For Amazon.de
http://USERNAME-country-DE:PASSWORD@gate.proxyhat.com:8080
# For Amazon.co.uk
http://USERNAME-country-GB:PASSWORD@gate.proxyhat.com:8080

2. Implement Smart Rotation

Never send more than 5-10 requests from a single IP to Amazon. ProxyHat's gateway automatically rotates IPs per request by default, but you should also implement application-level controls.

import requests
import random
import time
PROXY_BASE = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def make_request(url, max_retries=3):
    """Make a request with automatic retry on failure."""
    for attempt in range(max_retries):
        # Each request gets a fresh IP from the rotating proxy
        proxies = {"http": PROXY_BASE, "https": PROXY_BASE}
        headers = {
            "User-Agent": random.choice(USER_AGENTS),
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
        }
        try:
            response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
            # Check for CAPTCHA
            if "captcha" in response.text.lower() or response.status_code == 503:
                print(f"CAPTCHA/block detected on attempt {attempt + 1}")
                time.sleep(random.uniform(10, 30))  # Longer backoff
                continue
            if response.status_code == 200:
                return response
        except requests.RequestException:
            time.sleep(random.uniform(5, 15))
    return None

3. Randomize Request Patterns

Every aspect of your request pattern should include randomness to avoid statistical detection.

import random
import time
def random_delay(min_sec=2, max_sec=7):
    """Add human-like random delay."""
    delay = random.uniform(min_sec, max_sec)
    # Occasionally add a longer pause (simulates reading a page)
    if random.random() < 0.1:  # 10% chance
        delay += random.uniform(10, 30)
    time.sleep(delay)
def shuffle_targets(urls):
    """Randomize the order of URLs to avoid sequential patterns."""
    shuffled = urls.copy()
    random.shuffle(shuffled)
    return shuffled
def get_random_user_agent():
    """Return a realistic, current User-Agent string."""
    agents = [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    ]
    return random.choice(agents)

4. Match Geo-Location to Marketplace

Accessing amazon.com from a German IP or amazon.de from a Japanese IP is a strong signal of automated activity. Always match your proxy location to the target marketplace.

Marketplace	Proxy Country	ProxyHat Configuration
amazon.com	United States	USERNAME-country-US
amazon.co.uk	United Kingdom	USERNAME-country-GB
amazon.de	Germany	USERNAME-country-DE
amazon.co.jp	Japan	USERNAME-country-JP
amazon.fr	France	USERNAME-country-FR
amazon.in	India	USERNAME-country-IN

Check ProxyHat's full location list for all supported countries.

5. Handle Sessions Properly

Amazon tracks sessions via cookies. Accepting and returning cookies makes your requests look more like a real browser. For paginated browsing (search results, reviews), use sticky sessions to maintain the same IP and cookie jar.

# Sticky session for paginated scraping
PROXY_SESSION = "http://USERNAME-session-amz{session_id}:PASSWORD@gate.proxyhat.com:8080"
def create_session(session_id):
    """Create a requests session with sticky proxy and cookies."""
    session = requests.Session()
    proxy = PROXY_SESSION.format(session_id=session_id)
    session.proxies = {"http": proxy, "https": proxy}
    session.headers.update({
        "User-Agent": get_random_user_agent(),
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
    })
    return session

6. Monitor Your Success Rate

Track your HTTP 200 rate, CAPTCHA rate, and block rate in real time. Set thresholds to automatically throttle your scraper when detection increases.

class SuccessTracker:
    def __init__(self, captcha_threshold=0.1, block_threshold=0.05):
        self.total = 0
        self.success = 0
        self.captchas = 0
        self.blocks = 0
        self.captcha_threshold = captcha_threshold
        self.block_threshold = block_threshold
    def record(self, status):
        self.total += 1
        if status == "success":
            self.success += 1
        elif status == "captcha":
            self.captchas += 1
        elif status == "block":
            self.blocks += 1
    @property
    def should_throttle(self):
        if self.total < 10:
            return False
        captcha_rate = self.captchas / self.total
        block_rate = self.blocks / self.total
        return captcha_rate > self.captcha_threshold or block_rate > self.block_threshold
    @property
    def success_rate(self):
        return self.success / self.total if self.total > 0 else 0

Recovery After a Ban

If an IP gets banned, here is how to recover:

1. Stop immediately: Do not continue sending requests from the banned IP or nearby IPs.
2. Switch IPs: Use a fresh set of residential IPs from a different range. ProxyHat's large pool ensures you always have clean IPs available.
3. Adjust your approach: Review your request patterns, delays, and headers before resuming.
4. Start slowly: When resuming, begin with a low request rate and increase gradually.
5. Wait it out: Amazon bans typically expire within 24-48 hours for soft blocks and up to 7 days for hard blocks on specific IPs.

Node.js Ban Prevention

Here is an equivalent Node.js implementation using ProxyHat's Node SDK.

const axios = require("axios");
const { HttpsProxyAgent } = require("https-proxy-agent");
const PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080";
const USER_AGENTS = [
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
];
async function safeAmazonRequest(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const agent = new HttpsProxyAgent(PROXY_URL);
    try {
      const response = await axios.get(url, {
        httpsAgent: agent,
        headers: {
          "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
          "Accept-Language": "en-US,en;q=0.9",
          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
          "Accept-Encoding": "gzip, deflate, br",
        },
        timeout: 30000,
        validateStatus: () => true,
      });
      if (response.data.toLowerCase().includes("captcha") || response.status === 503) {
        console.log(`CAPTCHA/block on attempt ${attempt + 1}`);
        await new Promise((r) => setTimeout(r, 10000 + Math.random() * 20000));
        continue;
      }
      if (response.status === 200) return response;
    } catch (err) {
      await new Promise((r) => setTimeout(r, 5000 + Math.random() * 10000));
    }
  }
  return null;
}
// Random delay between requests
function randomDelay(minMs = 2000, maxMs = 7000) {
  const delay = minMs + Math.random() * (maxMs - minMs);
  return new Promise((r) => setTimeout(r, delay));
}

Prevention Checklist

Use this checklist before running any Amazon scraper:

• Using residential proxies (not datacenter)
• Proxy geo-location matches target marketplace
• User-Agent strings are current and rotated
• All standard browser headers are included
• Request delays are randomized (2-7 seconds minimum)
• URLs are shuffled, not processed sequentially
• Cookie handling is enabled
• CAPTCHA detection and automatic backoff are in place
• Success rate monitoring is active
• Concurrency is limited (start with 5-10 parallel requests)

Key Takeaways

• Amazon's detection is multi-layered: request fingerprints, behavioral patterns, and IP reputation all matter.
• Residential proxies are non-negotiable — datacenter IPs face immediate heightened scrutiny.
• Match proxy geo-location to the target Amazon marketplace.
• Randomize everything: delays, User-Agents, request order, and session patterns.
• Treat CAPTCHAs as early warnings and adjust immediately.
• Monitor success rates and automatically throttle when detection increases.

For a complete Amazon scraping setup, read our Amazon product data scraping guide and explore the full e-commerce scraping strategy. Get started with ProxyHat's residential proxies for reliable Amazon access.