Oxylabs + CaptchaAI: integração de proxy de datacenter

Um proxy resolve o bloqueio por IP; ele não resolve o CAPTCHA que aparece logo depois. Para rodar coletas em escala sem travar, você precisa das duas camadas trabalhando juntas:

• Proxy Oxylabs — distribui as requisições por IPs residenciais ou de datacenter e reduz os bloqueios por endereço.
• CaptchaAI — resolve o reCAPTCHA v2 ou o Cloudflare Turnstile que o site exibe e devolve o token pronto para enviar.

Este guia mostra como ligar as duas em Python: qual linha de proxy escolher, quando usar sessões fixas e onde encaixar a chamada de resolução.

Linha de proxies da Oxylabs: qual escolher

A Oxylabs oferece mais de 100 milhões de IPs residenciais e mais de 2 milhões de IPs de datacenter. A escolha muda o volume de CAPTCHA que você vai encontrar e, por consequência, quanto a CaptchaAI precisa trabalhar.

Como regra rápida ao parear com a CaptchaAI:

• Datacenter quando a prioridade é velocidade e volume.
• Residencial nos alvos que disparam muito CAPTCHA.
• ISP para um meio-termo em e-commerce e redes sociais.

Integração em Python

O fluxo tem três passos, independentemente da linguagem:

1. Busque a página pela saída de proxy da Oxylabs.
2. Detecte a sitekey do widget no HTML retornado.
3. Envie a sitekey à CaptchaAI, receba o token e anexe-o ao formulário.

Requisições com rotação de saída

A função fetch_page busca a página pelo proxy; solve_recaptcha envia a sitekey ao endpoint in.php e consulta res.php até o token ficar pronto.

import requests
import time

OXYLABS_USER = "customer-USERNAME"
OXYLABS_PASS = "PASSWORD"
OXYLABS_ENDPOINT = "pr.oxylabs.io:7777"

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

# Residential rotação de egress autorizada
proxies = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
}


def fetch_page(url, country=None):
    """Fetch page through Oxylabs proxy."""
    user = OXYLABS_USER
    if country:
        user += f"-cc-{country}"

    proxy = {
        "http": f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
        "https": f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
    }

    return requests.get(
        url,
        proxies=proxy,
        headers={
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36"
        },
        timeout=30,
    )


def solve_recaptcha(site_url, sitekey):
    """Solve via CaptchaAI."""
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": site_url,
        "json": 1,
    })
    data = resp.json()
    if data["status"] != 1:
        raise Exception(f"Submit: {data['request']}")

    task_id = data["request"]

    for _ in range(60):
        time.sleep(5)
        resp = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        })
        data = resp.json()
        if data["request"] == "CAPCHA_NOT_READY":
            continue
        if data["status"] == 1:
            return data["request"]
        raise Exception(f"Solve: {data['request']}")

    raise TimeoutError("Timeout")

Sessões fixas (mesmo IP)

Quando o fluxo tem várias etapas — carregar o formulário, resolver o CAPTCHA, enviar o token —, todas as requisições precisam sair do mesmo IP. A sessão fixa (-sessid-) mantém o endereço por cerca de 10 minutos.

def get_oxylabs_sticky_proxy(session_id, country=None):
    """Create Oxylabs sticky session (same IP)."""
    user = OXYLABS_USER + f"-sessid-{session_id}"
    if country:
        user += f"-cc-{country}"

    proxy_url = f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}"
    return {"http": proxy_url, "https": proxy_url}


# CAPTCHA workflow with sticky IP
import random, string
session = "".join(random.choices(string.ascii_lowercase, k=8))
proxy = get_oxylabs_sticky_proxy(session, country="us")

# All requests use the same IP
resp = requests.get("https://staging.example.com/qa-form", proxies=proxy)
# ... solve CAPTCHA ...
resp = requests.post("https://target.com/submit", proxies=proxy, data={
    "g-recaptcha-response": token,
})

API Web Scraper da Oxylabs com a CaptchaAI

Para sites em que a renderização integrada da Oxylabs não dá conta do CAPTCHA, deixe a Oxylabs entregar o HTML já renderizado e passe a sitekey encontrada para a CaptchaAI resolver.

def scrape_with_oxylabs_api(url):
    """Use Oxylabs Web Scraper API for rendering, CaptchaAI for CAPTCHAs."""
    resp = requests.post(
        "https://realtime.oxylabs.io/v1/queries",
        auth=(OXYLABS_USER, OXYLABS_PASS),
        json={
            "source": "universal",
            "url": url,
            "render": "html",
            "browser_instructions": [
                {"type": "wait", "wait_time_s": 3},
            ],
        },
    )

    result = resp.json()
    html = result["results"][0]["content"]

    # Check for CAPTCHA in rendered HTML
    import re
    sitekey_match = re.search(r'data-sitekey="([^"]+)"', html)

    if sitekey_match:
        sitekey = sitekey_match.group(1)
        token = solve_recaptcha(url, sitekey)
        return {"html": html, "captcha_solved": True, "token": token}

    return {"html": html, "captcha_solved": False}

Datacenter ou residencial: o que reduz o volume de CAPTCHA

O IP de datacenter é mais rápido e mais barato, mas é reconhecido com facilidade e dispara mais desafios. O IP residencial gera menos CAPTCHA, porém é mais lento. A regra prática: residencial nos alvos sensíveis, datacenter onde a velocidade importa mais — a CaptchaAI resolve o que aparecer nos dois casos.

# Datacenter: Fast but higher CAPTCHA rate
DC_PROXY = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@dc.pr.oxylabs.io:10000",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@dc.pr.oxylabs.io:10000",
}

# Residential: Slower but lower CAPTCHA rate
RES_PROXY = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@pr.oxylabs.io:7777",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@pr.oxylabs.io:7777",
}


def smart_proxy_selection(url, captcha_sensitive=True):
    """Pick proxy type based on target site sensitivity."""
    if captcha_sensitive:
        return RES_PROXY  # Less likely to trigger CAPTCHA
    return DC_PROXY  # Faster, CaptchaAI handles any CAPTCHAs

Pipeline paralelo com ThreadPoolExecutor

Em produção você raramente processa uma URL por vez. O padrão abaixo distribui as URLs por vários workers, cada um com sua própria sessão de IP. Alinhe max_workers ao número de threads do seu plano: no BASIC (US$ 15/mês, 5 threads) mantenha até 5 resoluções simultâneas; um plano como ADVANCE (US$ 90/mês, 50 threads) sustenta lotes bem maiores.

from concurrent.futures import ThreadPoolExecutor, as_completed

def process_url(url):
    session = "".join(random.choices(string.ascii_lowercase, k=8))
    proxy = get_oxylabs_sticky_proxy(session, country="us")

    try:
        resp = requests.get(url, proxies=proxy, timeout=30)

        import re
        match = re.search(r'data-sitekey="([^"]+)"', resp.text)

        if match:
            token = solve_recaptcha(url, match.group(1))
            return {"url": url, "status": "solved"}
        return {"url": url, "status": "no_captcha"}

    except Exception as e:
        return {"url": url, "status": "error", "error": str(e)}


urls = ["https://site1.com", "https://site2.com", "https://site3.com"]

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(process_url, u): u for u in urls}
    for future in as_completed(futures):
        print(future.result())

Se os workers rodam em uma região de nuvem no Brasil (por exemplo, AWS sa-east-1, em São Paulo), a latência até a CaptchaAI e até a saída de proxy entra no tempo total de resolução. Meça o RTT no seu próprio ambiente antes de aumentar o tamanho do pool.

Rode a coleta apenas em alvos que você tem permissão de acessar. Quando houver dados pessoais, considere as obrigações da LGPD (RGPD em Portugal) antes de começar — isto não é orientação jurídica.

Solução de problemas

Os erros mais comuns vêm do proxy, não da resolução. Comece por eles:

Perguntas frequentes

O token da CaptchaAI precisa sair pelo mesmo proxy da requisição?

Não. A CaptchaAI recebe apenas a sitekey e a URL da página e devolve o token; ela não passa pelo seu proxy. O que precisa manter o mesmo IP é a sequência carregar página → enviar o token, e é para isso que serve a sessão fixa.

Como reduzo a latência rodando a coleta a partir do Brasil?

Aproxime cada camada do alvo e meça o RTT no seu ambiente:

• Hospede os workers em uma região próxima, como AWS sa-east-1 (São Paulo), para sites brasileiros.
• Prefira saída de datacenter quando a latência pesar mais que o volume de CAPTCHA.
• Reaproveite a sessão fixa para evitar um novo handshake a cada requisição.

A CaptchaAI cobra por proxy ou por resolução?

Nenhum dos dois: o preço é por thread simultânea, com resoluções ilimitadas por thread no mês. O BASIC (US$ 15/mês) traz 5 threads; o custo do proxy é separado e fica com a Oxylabs.

Preciso de sessão fixa para todos os fluxos?

Só quando há mais de uma requisição encadeada no mesmo alvo — carregar o formulário, resolver o CAPTCHA e enviar. Para uma coleta de página única sem estado, a rotação padrão já serve e ainda distribui melhor a carga.

Guias relacionados

• Bright Data + CaptchaAI: integração de proxy
• Smartproxy + CaptchaAI: proxies residenciais
• Proxies de ISP ou de datacenter para CAPTCHA

Combine a infraestrutura de proxy da Oxylabs com a resolução da CaptchaAI — obtenha sua chave de API.