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"]', "user@example.com")
        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

Relevância AI com CapSolver
Como resolver reCAPTCHA v2 no Relevance AI com integração da CapSolver

Construa uma ferramenta da Relevance AI para resolver reCAPTCHA v2 usando o CapSolver. Automatize os envios de formulários via API sem automação de navegador.

web scraping
Logo of CapSolver

Adélia Cruz

03-Feb-2026

Ferramentas de Raspagem de Dados Instantâneas: Formas Rápidas de Extrair Dados da Web Sem Código
Ferramentas de Raspagem de Dados Instantâneas: Métodos Rápidos para Extrair Dados da Web Sem Código

Descubra as melhores ferramentas de raspagem de dados instantâneas para 2026. Aprenda formas rápidas de extrair dados da web sem código usando as melhores extensões e APIs para extração automatizada.

web scraping
Logo of CapSolver

Emma Foster

28-Jan-2026

Bloqueios de IP em 2026: Como Funcionam e Formas Práticas para Bypassar os Bloqueios
Bloqueios de IP em 2026: Como Funcionam e Métodos Práticos para Contornar Eles

Aprenda como burlar o banimento de IP em 2026 com nosso guia abrangente. Descubra técnicas modernas de bloqueio de IP e soluções práticas como proxies residenciais e solucionadores de CAPTCHA.

web scraping
Logo of CapSolver

Adélia Cruz

26-Jan-2026

Maxun com Integração CapSolver
Como resolver Captcha no Maxun com Integração do CapSolver

Um guia prático para integrar o CapSolver com o Maxun para raspagem de web realista. Aprenda como lidar com reCAPTCHA, Cloudflare Turnstile e sites protegidos por CAPTCHA usando fluxos de trabalho de pré-autenticação e robô.

web scraping
Logo of CapSolver

Adélia Cruz

21-Jan-2026

Browser4 com Integração do CapSolver
Como resolver Captcha no Browser4 com integração do CapSolver

Automação do Browser4 de alto throughput combinada com o CapSolver para lidar com desafios de CAPTCHA na extração de dados da web em larga escala.

web scraping
Logo of CapSolver

Adélia Cruz

21-Jan-2026

O que é um bot de raspagem e como construir um
O que é um bot de raspagem e como construir um

Aprenda o que é um bot de raspagem e como criar um para extração automática de dados. Descubra os melhores ferramentas, técnicas de navegação segura e práticas éticas de raspagem.

web scraping
Logo of CapSolver

Adélia Cruz

16-Jan-2026