CAPSOLVER
Blog
web scraping
Como integrar o Camoufox com o CapSolver para resolução de CAPTCHA sem interrupções

Como Integrar Camoufox com CapSolver para Resolução de CAPTCHA Sem Precedentes

Logo of CapSolver

Adélia Cruz

Neural Network Developer

16-Dec-2025

TL;DR: Use o Camoufox para evadir a fingerprinting do navegador e o CapSolver para resolver automaticamente CAPTCHAs como Cloudflare Turnstile e reCAPTCHA v2/v3. Juntos, eles permitem automação web estável e semelhante à humana em larga escala com mínima detecção e altas taxas de sucesso.

Introdução

A automação web tornou-se essencial para coleta de dados, testes e várias operações comerciais. No entanto, sites modernos implementam medidas anti-bot sofisticadas e CAPTCHAs que podem interromper até mesmo scripts de automação bem elaborados.

A combinação do Camoufox e do CapSolver oferece uma solução poderosa para esse desafio:

  • Camoufox: Um navegador anti-detecto de código aberto baseado no Firefox que evita a detecção de bots por meio de injeção de fingerprint avançada
  • CapSolver: Um serviço de resolução de CAPTCHA baseado em IA que lida com Cloudflare Turnstile, reCAPTCHA e mais

Juntos, essas ferramentas permitem automação web sem interrupções que evita tanto a detecção de fingerprint quanto os desafios de CAPTCHA.

Objetivos da Integração

Este guia o ajudará a atingir três objetivos principais:

  1. Evitar a Detecção de Bots - Use a injeção de fingerprint do Camoufox para parecer um navegador legítimo
  2. Resolver CAPTCHAs Automaticamente - Integre a API do CapSolver para lidar com desafios de CAPTCHA sem intervenção manual
  3. Manter Comportamento Semelhante ao Humano - Combine movimentos do mouse humanizados com resolução inteligente de CAPTCHA

O que é o Camoufox?

Camoufox é uma versão personalizada minimalista e discreta do Firefox projetada especificamente para raspagem de web e automação. Ao contrário de outras soluções anti-detecto que dependem de injeção de JavaScript (que pode ser detectada), o Camoufox implementa a injeção de fingerprint no nível C++ dentro do próprio navegador.

Funcionalidades Principais

  • Injeção de Fingerprint - Falsifica propriedades do navegador, dimensões da tela, WebGL, WebRTC, fontes e mais no nível nativo
  • Movimento do Mouse Semelhante ao Humano - Algoritmo integrado de humanização do cursor para interações realistas
  • Integração com BrowserForge - Gera fingerprints que imitam distribuições de dispositivos do mundo real
  • Suporte a GeoIP - Calcula automaticamente fuso horário, local e geolocalização com base no IP do proxy
  • Suporte a Adicionais do Firefox - Carrega extensões personalizadas, incluindo bloqueadores de anúncios

Instalação

bash Copy 
# Instale o pacote Python
pip install -U camoufox[geoip]

# Baixe o navegador Camoufox
camoufox fetch

Uso Básico

python Copy 
from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

O que é o CapSolver?

CapSolver é um serviço de resolução de CAPTCHA automático baseado em IA que suporta uma ampla gama de tipos de CAPTCHA. Ele fornece uma API simples que permite enviar desafios de CAPTCHA e receber soluções em segundos.

Tipos de CAPTCHA Suportados

  • Cloudflare Turnstile - O desafio anti-bot mais comum atualmente
  • reCAPTCHA v2 - Variantes baseadas em imagem e invisíveis
  • reCAPTCHA v3 - Verificação baseada em pontuação
  • AWS WAF - CAPTCHA da Amazon Web Services
  • E muitos mais...

Começando com o CapSolver

  1. Registre-se em capsolver.com
  2. Adicione fundos à sua conta
  3. Obtenha sua chave de API no painel de controle

Bônus: Use o código CAMOUFOX ao se cadastrar para receber créditos extras!

Desafios Pré-Integração

Antes de combinar o Camoufox com o CapSolver, a automação web enfrentava vários problemas:

Desafio Impacto
Detecção de fingerprint do navegador Scripts bloqueados antes de atingirem o conteúdo
Desafios CAPTCHA Resolução manual necessária, interrompendo a automação
Sistemas de reputação de IP Proxies rapidamente marcados e banidos
Análise de comportamento Padrões não humanos detectados

A integração do Camoufox + CapSolver resolve todos esses desafios em um único fluxo de trabalho.

Métodos de Integração

Método 1: Integração via API (Recomendado)

O método de integração via API oferece controle total sobre o processo de resolução de CAPTCHA e funciona com qualquer tipo de CAPTCHA.

Requisitos de Configuração

bash Copy 
pip install camoufox[geoip] httpx

Padrão de Integração Básico

python Copy 
import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Crie uma tarefa de resolução de CAPTCHA e retorne o ID da tarefa."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": task_payload
            }
        )
        result = response.json()
        if result.get("errorId") != 0:
            raise Exception(f"Erro do CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Verifique o resultado da tarefa até que seja resolvido ou expire o tempo."""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            result = response.json()

            if result.get("status") == "ready":
                return result["solution"]
            elif result.get("status") == "failed":
                raise Exception(f"Tarefa falhou: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("A resolução de CAPTCHA expirou!")


async def solve_captcha(task_payload: dict) -> dict:
    """Fluxo completo de resolução de CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

Você também pode usar a extensão do CapSolver com o Camoufox para uma abordagem mais automática.

Etapas de Instalação

  1. Baixe a extensão do CapSolver em capsolver.com/en/extension
  2. Extraia os arquivos da extensão
  3. Carregue-a no Camoufox:
python Copy 
from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/caminho/para/a/extensão/capsolver"],
    headless=False  # Extensões exigem modo com interface
) as browser:
    page = browser.new_page()
    # A extensão detectará e resolverá CAPTCHAs automaticamente

Exemplos de Código

Exemplo 1: Resolvendo Cloudflare Turnstile

Cloudflare Turnstile é um dos desafios de CAPTCHA mais comuns. Aqui está como resolvê-lo:

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolva o Cloudflare Turnstile e retorne o token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crie a tarefa
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

        # Verifique o resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/pagina-protegida"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encontre isso no código da página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Aguarde o Turnstile carregar
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Resolva o CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Obteve token do Turnstile: {token[:50]}...")

        # Injete o token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // Defina o callback oculto se estiver presente
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Submeta o formulário
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Turnstile evadido com sucesso!")


if __name__ == "__main__":
    asyncio.run(main())

Exemplo 2: Resolvendo reCAPTCHA v2

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolva o reCAPTCHA v2 e retorne o token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crie a tarefa
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Erro: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Verifique o resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falha: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/login"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Encontre no código da página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Seleção aleatória de sistema operacional
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Preencha os campos do formulário com pausas semelhantes às humanas
        await page.fill('input[name="username"]', "[email protected]")
        await asyncio.sleep(0.5)  # Pausa semelhante à humana
        await page.fill('input[name="password"]', "password123")

        # Resolva o CAPTCHA
        print("Resolvendo reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Obteve token: {token[:50]}...")

        # Injete o token no campo de resposta do reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Submeta o formulário
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Login bem-sucedido!")


if __name__ == "__main__":
    asyncio.run(main())

Exemplo 3: Resolvendo reCAPTCHA v3

O reCAPTCHA v3 é baseado em pontuação e não exige interação do usuário. Você precisa especificar o parâmetro de ação.

python Copy 
import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolva o reCAPTCHA v3 com ação e pontuação mínima especificadas."""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV3TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                    "pageAction": action,
                    "minScore": min_score
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Erro: {result.get('errorDescription')}")

        task_id = result["taskId"]

        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falha: {data.get('errorDescription')}")

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/pesquisa"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # Máximo de 2 segundos de movimentos humanizados
        headless=True,  # Pode ser executado em modo headless para v3
        geoip=True,  # Detecta automaticamente a geolocalização a partir do proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Resolva o reCAPTCHA v3 com ação "pesquisa"
        print("Resolvendo reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="pesquisa",
            min_score=0.9  # Solicite uma pontuação alta
        )

        # Execute o callback com o token
        await page.evaluate(f'''
            // Envie o token via callback do site

grecaptcha.execute('{chave_v3_recaptcha}', {{ação: 'pesquisa'}})
.then(function(tokenOriginal) {{
// Substitua pelo nosso token resolvido
enviarPesquisa('{token}');
}});
''')

Copy 
    print("bypass de reCAPTCHA v3 concluído!")

if name == "main":
asyncio.run(main())

Copy 
---

## Boas Práticas

### 1. Rotação de Proxy com GeoIP

Use o recurso de GeoIP do Camoufox para corresponder automaticamente aos impressões digitais com a localização do seu proxy:

```python
async with AsyncCamoufox(
    geoip=True,  # Detectar automaticamente a partir do IP do proxy
    proxy={
        "servidor": "http://proxy.example.com:8080",
        "usuario": "user",
        "senha": "pass"
    }
) as browser:
    # A impressão digital corresponderá à localização geográfica do proxy
    pass

2. Consistência da Impressão Digital

Mantenha as impressões digitais consistentes dentro de uma sessão, mas altere-as entre sessões:

python Copy 
from browserforge.fingerprints import Tela

# Restrinja para tamanhos de tela comuns
tela = Tela(
    largura_min=1280,
    largura_max=1920,
    altura_min=720,
    altura_max=1080
)

async with AsyncCamoufox(
    sistema_operacional="windows",
    tela=tela,
) as browser:
    pass

3. Limitação de Taxa

Evite disparar limites de taxa adicionando atrasos:

python Copy 
import random

async def atraso_humano():
    """Atraso aleatório para imitar comportamento humano."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Use entre ações
await page.clicar('botão')
await atraso_humano()
await page.preencher('input', 'texto')

4. Tratamento de Erros

Sempre implemente tratamento adequado de erros para resolução de CAPTCHA:

python Copy 
async def resolver_com_retentativas(payload_tarefa: dict, max_tentativas: int = 3) -> dict:
    """Resolver CAPTCHA com lógica de tentativas."""
    for tentativa in range(max_tentativas):
        try:
            return await resolver_captcha(payload_tarefa)
        except TimeoutError:
            if tentativa < max_tentativas - 1:
                print(f"Tempo esgotado, tentando novamente... ({tentativa + 1}/{max_tentativas})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # Não tentar novamente em erros de saldo
            if tentativa < max_tentativas - 1:
                await asyncio.sleep(2)
            else:
                raise

Bônus: Comece Hoje Mesmo!

Pronto para impulsionar sua automação web com o Camoufox e o CapSolver?

Use o código CAMOUFOX ao se inscrever no CapSolver para receber créditos extras!

Esse bônus exclusivo ajuda você a começar a resolver CAPTCHAs imediatamente.

Conclusão

A integração do Camoufox e do CapSolver cria uma ferramenta poderosa para automação web:

  • Camoufox lida com detecção de bots com spoofing de impressão digital de nível nativo
  • CapSolver lida com CAPTCHAs com resolução baseada em IA
  • Juntos eles permitem automação sem interrupções que parece totalmente humana

Seja você construindo raspadores de web, sistemas de testes automatizados ou pipelines de coleta de dados, essa combinação oferece a confiabilidade e o disfarce que você precisa.

Perguntas Frequentes

Q: Quais tipos de CAPTCHA funcionam melhor com essa integração?

A: O CapSolver suporta todos os principais tipos de CAPTCHA. Turnstile da Cloudflare e reCAPTCHA v2/v3 têm as maiores taxas de sucesso. A integração funciona perfeitamente com qualquer CAPTCHA que o CapSolver suporte.

Q: Posso usar isso no modo headless?

A: Sim! O Camoufox suporta o modo headless e mantém suas capacidades de spoofing de impressão digital. Para reCAPTCHA v3 e CAPTCHAs baseados em token, o modo headless funciona perfeitamente. Para CAPTCHAs v2 visíveis, o modo headed pode oferecer melhores resultados.

Q: Como encontrar a site key de um CAPTCHA?

A: Procure no código fonte da página por:

  • Turnstile: atributo data-sitekey ou elementos cf-turnstile
  • reCAPTCHA: atributo data-sitekey no div g-recaptcha

Q: O que fazer se a resolução do CAPTCHA falhar?

A: Soluções comuns:

  1. Verifique sua chave de API e saldo
  2. Certifique-se de que a site key está correta
  3. Verifique se a URL da página corresponde à onde o CAPTCHA aparece
  4. Para v3, tente ajustar o parâmetro de ação e a pontuação mínima
  5. Implemente lógica de tentativa com atrasos

Q: O Camoufox funciona com o Selenium?

A: O Camoufox é baseado no Playwright, não no Selenium. No entanto, você pode usar o mesmo padrão de integração com a API do CapSolver com qualquer framework de automação de navegador.

Declaração de Conformidade: As informações fornecidas neste blog são apenas para fins informativos. A CapSolver está comprometida em cumprir todas as leis e regulamentos aplicáveis. O uso da rede CapSolver para atividades ilegais, fraudulentas ou abusivas é estritamente proibido e será investigado. Nossas soluções de resolução de captcha melhoram a experiência do usuário enquanto garantem 100% de conformidade ao ajudar a resolver dificuldades de captcha durante a coleta de dados públicos. Incentivamos o uso responsável de nossos serviços. Para mais informações, visite nossos Termos de Serviço e Política de Privacidade.

Mais

Fluxo de trabalho de resolução de CAPTCHA do Camoufox e do CapSolver
Como Integrar Camoufox com CapSolver para Resolução de CAPTCHA Sem Precedentes

Aprenda como integrar o Camoufox com o CapSolver para contornar o Cloudflare Turnstile e o reCAPTCHA de forma confiável em larga escala.

web scraping
Logo of CapSolver

Adélia Cruz

16-Dec-2025

Como resolver CAPTCHAs em Python Usando o Botasaurus e o CapSolver (Guia Completo)
Como resolver CAPTCHAs em Python usando Botasaurus e CapSolver (Guia Completo)

Aprenda a integrar o Botasaurus (framework de raspagem de web em Python) com a API do CapSolver para resolver automaticamente reCAPTCHA v2/v3 e Turnstile.

web scraping
Logo of CapSolver

Adélia Cruz

15-Dec-2025

Lumiproxy
Lumiproxy: Proxy Premium para Scraping de Web e Coleta de Dados

Neste artigo, mostraremos o que é Lumiproxy e os serviços que eles oferecem.

web scraping
Logo of CapSolver

Ethan Collins

12-Dec-2025

Aba Proxy
Tabproxy: Bom custo proxy residencial internacional

Neste artigo, vamos mostrar para você o que é o Tabproxy e os serviços que eles oferecem.

web scraping
Logo of CapSolver

Ethan Collins

12-Dec-2025

erros de raspagem de web
O que são erros 402, 403, 404 e 429 em raspagem de web? Um Guia Completo

Domine o tratamento de erros de raspagem de web entendendo o que são os erros 402, 403, 404 e 429. Aprenda a corrigir o erro 403 Proibido, implementar soluções para o erro de limitação de taxa 429 e tratar o código de status Payment Required emergente 402.

web scraping
Logo of CapSolver

Lucas Mitchell

12-Dec-2025

IP2Mundo
Proxies Residenciais IP2World: Soluções Líderes de Proxies IP Globais

Neste artigo, vamos mostrar o que é o IP2World e os serviços que eles oferecem.

web scraping
Logo of CapSolver

Ethan Collins

12-Dec-2025