CAPTCHA Handling for Sneaker Bot Automation

Sneaker release sites protect checkout pages with CAPTCHAs to block bots. Sub-second solving is critical — a 3-second delay can mean the difference between a successful cop and an L. CaptchaAI provides the fast token delivery these workflows demand.

Common CAPTCHAs on Sneaker Sites

Why Speed Matters

Drop timeline (limited release):
  00:00  — Drop goes live
  00:01  — 50,000 bots hit checkout
  00:03  — Sizes start selling out
  00:05  — Popular sizes gone
  00:10  — Most stock depleted
  00:30  — Fully sold out

Every second of CAPTCHA delay = lost inventory.

Pre-Solving Strategy

Submit CAPTCHA tasks before the drop. Tokens are valid for ~120 seconds — solve in advance and use at checkout.

import requests
import time
import threading
from queue import Queue

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"


class TokenBank:
    """Pre-solve and bank CAPTCHA tokens for instant use at checkout."""

    def __init__(self, sitekey, pageurl, captcha_method="userrecaptcha",
                 max_tokens=10, token_ttl=110):
        self.sitekey = sitekey
        self.pageurl = pageurl
        self.method = captcha_method
        self.max_tokens = max_tokens
        self.token_ttl = token_ttl
        self.tokens = Queue()
        self._running = False

    def start(self):
        self._running = True
        for _ in range(self.max_tokens):
            t = threading.Thread(target=self._solve_loop, daemon=True)
            t.start()

    def stop(self):
        self._running = False

    def get_token(self, timeout=30):
        """Get a pre-solved token instantly."""
        token, solved_at = self.tokens.get(timeout=timeout)
        age = time.time() - solved_at
        if age > self.token_ttl:
            # Token expired, get next one
            return self.get_token(timeout=timeout)
        return token

    def _solve_loop(self):
        while self._running:
            try:
                token = self._solve()
                self.tokens.put((token, time.time()))
            except Exception:
                time.sleep(2)

    def _solve(self):
        resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
            "key": CAPTCHAAI_KEY,
            "method": self.method,
            "googlekey": self.sitekey,
            "pageurl": self.pageurl,
            "json": 1,
        })
        task_id = resp.json()["request"]

        for _ in range(60):
            time.sleep(3)
            result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
                "key": CAPTCHAAI_KEY, "action": "get",
                "id": task_id, "json": 1,
            })
            data = result.json()
            if data["request"] != "CAPCHA_NOT_READY":
                return data["request"]

        raise TimeoutError("Solve timeout")


# Pre-solve tokens before drop
bank = TokenBank(
    sitekey="6LcR_RsTAAAAAxxxxxxxx",
    pageurl="https://www.example-sneakers.com/checkout",
    max_tokens=5,
)
bank.start()

# Wait for drop, then instantly use tokens
time.sleep(10)  # Simulate waiting for drop
token = bank.get_token(timeout=5)
print(f"Token ready: {token[:40]}...")
bank.stop()

Checkout Flow Integration

import uuid

STICKY_PROXY = {
    "http": "http://user-session-{sid}:pass@proxy.example.com:5000",
    "https": "http://user-session-{sid}:pass@proxy.example.com:5000",
}


def checkout_flow(product_url, size, payment_profile, token_bank):
    """Complete checkout with pre-solved CAPTCHA token."""
    session = requests.Session()
    sid = uuid.uuid4().hex[:8]
    proxy = {k: v.format(sid=sid) for k, v in STICKY_PROXY.items()}
    session.proxies = proxy
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) "
        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 "
        "Mobile/15E148 Safari/604.1",
    })

    # Step 1: Add to cart
    resp = session.post(f"{product_url}/cart", json={
        "size": size,
        "quantity": 1,
    })

    if resp.status_code != 200:
        return {"success": False, "reason": "cart_failed"}

    # Step 2: Get pre-solved token
    token = token_bank.get_token(timeout=5)

    # Step 3: Submit checkout with token
    resp = session.post(f"{product_url}/checkout", json={
        "payment": payment_profile,
        "captcha_token": token,
    })

    return {
        "success": resp.status_code == 200,
        "order_id": resp.json().get("order_id"),
    }

Proxy Recommendations for Sneaker Sites

Nike and Adidas heavily fingerprint datacenter IPs. Use residential or mobile proxies.

reCAPTCHA v3 Score Optimization

Nike SNKRS uses reCAPTCHA v3 with a high score threshold. Maximize your score:

def solve_recaptcha_v3_high_score(sitekey, pageurl, action="checkout"):
    """Request minimum score of 0.7 for sneaker sites."""
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "version": "v3",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "action": action,
        "min_score": "0.7",
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(40):
        time.sleep(3)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = result.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]

    raise TimeoutError("v3 solve timeout")

Troubleshooting

FAQ

How fast does CaptchaAI solve reCAPTCHA for sneaker sites?

Average solve time is 5-15 seconds. Pre-solving tokens before the drop eliminates this delay from the checkout flow.

Which CAPTCHA type is hardest on sneaker sites?

reCAPTCHA v3 on Nike SNKRS, since it requires a high score (0.7+). CaptchaAI supports min_score to meet this threshold.

Should I use one token per checkout task?

Yes. Each CAPTCHA token is single-use. Pre-solve enough tokens for the number of checkout attempts you plan to run.

Is a mobile proxy really necessary?

For Nike and Adidas — yes. These sites aggressively block datacenter and lower-quality residential IPs.

Related Guides

• Browser Session Persistence
• Mobile Proxies for CAPTCHA Solving
• Proxy Quality Affects Solve Rate

Win drops with pre-solved CAPTCHAs — get your CaptchaAI key and start banking tokens before checkout.