CAPSOLVER
Blog
web scraping
Como resolver Captcha no Agno com integração do CapSolver

Como resolver CAPTCHA no Agno com integração do CapSolver

Logo of CapSolver

Adélia Cruz

Neural Network Developer

13-Jan-2026

Agno com Integração do CapSolver

À medida que a automação impulsionada por IA se torna mais prática em fluxos de trabalho do mundo real, o Agno emergiu como um framework rápido e de privacidade primeiro para construir sistemas multiagente autônomos. Quando esses agentes interagem com sites por meio de raspagem, coleta de dados ou navegação automatizada, o CAPTCHA muitas vezes se torna um problema.

CapSolver ajuda a resolver esse problema permitindo que os agentes do Agno lidem com com eficácia páginas protegidas por CAPTCHA sem interromper o fluxo de automação. Juntos, Agno e CapSolver tornam mais fácil construir automação escalável e sem intervenção que funciona em sites reais.

O que é Agno?

Agno é um framework multiagente de código aberto e runtime para construir sistemas de IA que rodam totalmente em sua própria infraestrutura. Foi projetado com desempenho e privacidade em mente — sem plano de controle externo e sem dados saindo do seu ambiente.

Principais Funcionalidades do Agno

  • Alta Performance: Muito mais rápido e eficiente em termos de memória do que muitos frameworks de agentes
  • Privacidade Primeiro: Auto-hospedado, com controle total sobre dados e execução
  • Sistemas Multiagente: Agentes podem colaborar, especializar-se e coordenar tarefas
  • Flexibilidade de Modelos: Suporta OpenAI, Anthropic, Google e muitos outros provedores
  • Runtime Pronto para Produção: Inclui um runtime baseado em FastAPI para implantar agentes
  • Ferramentas Ricas: Ferramentas integradas para automação da web, APIs, bancos de dados e mais
  • Memória Persistente: Agentes podem reter contexto entre sessões

O que é CapSolver?

CapSolver é um serviço líder de resolução de CAPTCHA que fornece soluções baseadas em IA para contornar diversos desafios de CAPTCHA. Com suporte para vários tipos de CAPTCHA e tempos de resposta rápidos, o CapSolver se integra sem problemas em fluxos automatizados.

Tipos de CAPTCHA Suportados

Por que Integrar o CapSolver com o Agno?

Ao construir agentes do Agno que interagem com sites — seja para coleta de dados, testes automatizados ou agregação de conteúdo — os desafios de CAPTCHA tornam-se uma barreira significativa. Para uma análise mais aprofundada sobre como resolver CAPTCHAs em ambientes de navegador automatizado, consulte nosso guia sobre como resolver CAPTCHA no Puppeteer. Aqui está por que a integração importa:

  1. Fluxos de Trabalho dos Agentes Ininterruptos: Os agentes podem completar suas tarefas sem intervenção manual. Para mais soluções sobre CAPTCHAs em raspagem da web, consulte nosso artigo: Melhor Forma de Resolver CAPTCHA Durante a Raspagem da Web.
  2. Privacidade Preservada: Tanto o Agno quanto o CapSolver permitem que você mantenha o controle sobre seus dados
  3. Automação Escalável: Lidar com múltiplos desafios de CAPTCHA em operações de agentes concorrentes
  4. Custo Eficiente: Pague apenas pelos CAPTCHAs resolvidos com sucesso
  5. Alta Taxa de Sucesso: Precisão líder da indústria para todos os tipos de CAPTCHA suportados.

Instalação

Primeiro, instale os pacotes necessários:

bash Copy 
pip install agno
pip install requests

O Agno é independente de modelo com suporte integrado a 23+ provedores de LLM:

python Copy 
# OpenAI
from agno.models.openai import OpenAIChat

# Claude da Anthropic
from agno.models.anthropic import Claude

# Gemini da Google
from agno.models.google import Gemini

# E muitos mais...

Criando uma Ferramenta Personalizada do CapSolver para o Agno

O Agno permite que você crie ferramentas personalizadas que os agentes podem usar para realizar suas tarefas. Aqui está como criar uma ferramenta do CapSolver para lidar com desafios de CAPTCHA:

Implementação Básica da Ferramenta do CapSolver

python Copy 
import requests
import time
from agno.tools import tool

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_captcha(
    website_url: str,
    website_key: str,
    captcha_type: str = "ReCaptchaV2TaskProxyLess"
) -> str:
    """
    Resolve desafios de CAPTCHA usando a API do CapSolver.

    Args:
        website_url: A URL do site com CAPTCHA
        website_key: A chave do site do CAPTCHA
        captcha_type: Tipo de CAPTCHA (ReCaptchaV2TaskProxyLess, ReCaptchaV3TaskProxyLess, AntiTurnstileTaskProxyLess)

    Returns:
        O token de solução do CAPTCHA
    """
    # Cria tarefa
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": captcha_type,
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

    if result.get("errorId") != 0:
        return f"Erro ao criar tarefa: {result.get('errorDescription')}"

    task_id = result.get("taskId")

    # Verifica resultado
    for _ in range(60):
        time.sleep(2)

        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            solution = result.get("solution", {})
            return solution.get("gRecaptchaResponse") or solution.get("token")
        elif result.get("status") == "failed":
            return f"Tarefa falhou: {result.get('errorDescription')}"

    return "Tempo esgotado esperando pela solução do CAPTCHA"

Resolvendo Diferentes Tipos de CAPTCHA

Solucionador de reCAPTCHA v2

python Copy 
import requests
import time
from agno.tools import tool

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_recaptcha_v2(website_url: str, website_key: str) -> str:
    """
    Resolve desafios de reCAPTCHA v2 usando o CapSolver.

    Args:
        website_url: A URL do site com reCAPTCHA v2
        website_key: A chave do site (atributo data-sitekey)

    Returns:
        O token g-recaptcha-response
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "ReCaptchaV2TaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    # Cria tarefa
    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    # Verifica resultado
    for attempt in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

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

    return "Tempo esgotado esperando pela solução"

Solucionador de reCAPTCHA v3

python Copy 
import requests
import time
from agno.tools import tool

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_recaptcha_v3(
    website_url: str,
    website_key: str,
    page_action: str = "submit",
    min_score: float = 0.7
) -> str:
    """
    Resolve desafios de reCAPTCHA v3 com verificação baseada em pontuação.

    Args:
        website_url: A URL do site com reCAPTCHA v3
        website_key: A chave do site do reCAPTCHA
        page_action: O parâmetro de ação para reCAPTCHA v3
        min_score: Pontuação mínima necessária (0,1 a 0,9)

    Returns:
        O token g-recaptcha-response
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "ReCaptchaV3TaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": website_key,
            "pageAction": page_action,
            "minScore": min_score
        }
    }

    # Cria tarefa
    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    # Verifica resultado
    for attempt in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

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

    return "Tempo esgotado esperando pela solução"

Solucionador de Cloudflare Turnstile

python Copy 
import requests
import time
from agno.tools import tool

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_turnstile(website_url: str, website_key: str) -> str:
    """
    Resolve desafios de Cloudflare Turnstile.

    Args:
        website_url: A URL do site com Turnstile
        website_key: A chave do site do widget Turnstile

    Returns:
        O token do Turnstile
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "AntiTurnstileTaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    # Cria tarefa
    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    # Verifica resultado
    for attempt in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        if result.get("status") == "failed":
            return f"Falha: {result.get('errorDescription')}"

    return "Tempo esgotado esperando pela solução"

Solucionador de Desafio Cloudflare (5s)

python Copy 
import requests
import time
from agno.tools import tool

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_cloudflare_challenge(website_url: str, proxy: str) -> dict:
    """
    Resolve páginas de desafio Cloudflare de 5 segundos.

    Args:
        website_url: A URL da página protegida
        proxy: Proxy no formato: http://user:pass@ip:port

    Returns:
        Dicionário com cookies e user_agent para acessar a página protegida
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "AntiCloudflareTask",
            "websiteURL": website_url,
            "proxy": proxy
        }
    }

    # Cria tarefa
    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

    if result.get("errorId") != 0:
        return {"error": result.get('errorDescription')}

    task_id = result.get("taskId")

    # Verifica resultado
    for attempt in range(60):
        time.sleep(3)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            return {
                "cookies": result["solution"]["cookies"],
                "user_agent": result["solution"]["userAgent"]
            }
        if result.get("status") == "failed":
            return {"error": result.get('errorDescription')}

    return {"error": "Tempo esgotado esperando pela solução"}

Exemplo Completo de Agente do Agno

Aqui está um exemplo completo de um agente do Agno usando o CapSolver para lidar com desafios de CAPTCHA:

python Copy 
import os
import requests
import time
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool

# Configuração
CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"
os.environ["OPENAI_API_KEY"] = "SUA_CHAVE_API_DO_OPENAI"


@tool
def solve_recaptcha_v2(website_url: str, website_key: str) -> str:
    """
    Resolve desafios de reCAPTCHA v2 usando o CapSolver.

    Args:
        website_url: A URL do site com reCAPTCHA v2
        website_key: A chave do site (atributo data-sitekey)

    Returns:
        O token g-recaptcha-response ou mensagem de erro
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "ReCaptchaV2TaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    for _ in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

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

    return "Tempo esgotado"


@tool
def solve_turnstile(website_url: str, website_key: str) -> str:
    """
    Resolve desafios de Cloudflare Turnstile.

    Args:
        website_url: A URL do site com Turnstile
        website_key: A chave do site do widget Turnstile

    Returns:
        O token do Turnstile ou mensagem de erro
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": "AntiTurnstileTaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    for _ in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        if result.get("status") == "failed":
            return f"Falha: {result.get('errorDescription')}"

    return "Tempo esgotado"
"https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        if result.get("status") == "failed":
            return f"Falha: {result.get('errorDescription')}"

    return "Tempo esgotado"


@tool
def check_capsolver_balance() -> str:
    """
    Verifica o saldo atual da conta CapSolver.

    Retorna:
        Informação sobre o saldo atual
    """
    response = requests.post(
        "https://api.capsolver.com/getBalance",
        json={"clientKey": CAPSOLVER_API_KEY}
    )
    result = response.json()

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

    return f"Saldo: ${result.get('balance', 0):.4f}"


# Crie o Agente de Web Scraping
web_scraper_agent = Agent(
    name="Agente de Web Scraping",
    model=OpenAIChat(id="gpt-4o"),
    tools=[solve_recaptcha_v2, solve_turnstile, check_capsolver_balance],
    description="Especialista em web scraping que resolve desafios CAPTCHA automaticamente",
    instructions=[
        "Você é um especialista em web scraping com capacidade de resolver CAPTCHAs.",
        "Ao encontrar um CAPTCHA, identifique o tipo e use o solucionador apropriado.",
        "Para reCAPTCHA v2, use solve_recaptcha_v2 com a URL e a chave do site.",
        "Para Turnstile, use solve_turnstile com a URL e a chave do site.",
        "Sempre verifique o saldo antes de iniciar tarefas de scraping grandes."
    ],
    markdown=True
)


def main():
    print("=" * 60)
    print("Demonstração de Integração Agno + CapSolver")
    print("=" * 60)

    # Tarefa: Resolver um desafio de reCAPTCHA
    task = """
    Preciso que você resolva um desafio de reCAPTCHA v2.

    URL do site: https://www.google.com/recaptcha/api2/demo
    Chave do site: 6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-

    Por favor, resolva este CAPTCHA e relate os primeiros 50 caracteres do token.
    Verifique também meu saldo no CapSolver antes de começar.
    """

    response = web_scraper_agent.run(task)
    print("\nResposta do Agente:")
    print(response.content)


if __name__ == "__main__":
    main()

Usando Equipes do Agno com CapSolver

O Agno suporta equipes de agentes multiagente. Aqui está como criar uma equipe com agentes especializados em resolução de CAPTCHA:

python Copy 
from agno.agent import Agent
from agno.team import Team
from agno.models.openai import OpenAIChat
from agno.tools import tool
import requests
import time

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_CAPSOLVER"


@tool
def solve_any_captcha(
    website_url: str,
    website_key: str,
    captcha_type: str = "ReCaptchaV2TaskProxyLess"
) -> str:
    """Solucionador universal de CAPTCHA que suporta vários tipos."""
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": captcha_type,
            "websiteURL": website_url,
            "websiteKey": website_key
        }
    }

    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    result = response.json()

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

    task_id = result.get("taskId")

    for _ in range(60):
        time.sleep(2)
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        ).json()

        if result.get("status") == "ready":
            solution = result.get("solution", {})
            return solution.get("gRecaptchaResponse") or solution.get("token")
        if result.get("status") == "failed":
            return f"Falha: {result.get('errorDescription')}"

    return "Tempo esgotado"


# Agente Especialista em CAPTCHA
captcha_agent = Agent(
    name="Especialista em CAPTCHA",
    model=OpenAIChat(id="gpt-4o"),
    tools=[solve_any_captcha],
    description="Especialista em identificar e resolver diferentes tipos de CAPTCHA",
    instructions=[
        "Identificar o tipo de CAPTCHA a partir da análise da página",
        "Usar o solucionador apropriado com os parâmetros corretos",
        "Relatar sucesso ou falha claramente"
    ]
)

# Agente de Extração de Dados
data_agent = Agent(
    name="Extrator de Dados",
    model=OpenAIChat(id="gpt-4o"),
    description="Extrai e processa dados de páginas da web",
    instructions=[
        "Extrair dados estruturados do conteúdo HTML",
        "Solicitar resolução de CAPTCHA quando necessário",
        "Validar e limpar os dados extraídos"
    ]
)

# Crie a equipe
scraping_team = Team(
    name="Equipe de Web Scraping",
    agents=[captcha_agent, data_agent],
    description="Equipe especializada em web scraping com tratamento de CAPTCHA"
)

Como Enviar Tokens de CAPTCHA

Cada tipo de CAPTCHA requer um método de envio diferente:

reCAPTCHA v2/v3 - Injeção de Token

python Copy 
from selenium import webdriver
from selenium.webdriver.common.by import By

def submit_recaptcha_token(driver, token: str):
    """Injeta o token reCAPTCHA e envia."""
    recaptcha_response = driver.find_element(By.ID, "g-recaptcha-response")
    driver.execute_script("arguments[0].style.display = 'block';", recaptcha_response)
    recaptcha_response.clear()
    recaptcha_response.send_keys(token)

    form = driver.find_element(By.TAG_NAME, "form")
    form.submit()

Turnstile - Injeção de Token

python Copy 
def submit_turnstile_token(driver, token: str):
    """Injeta o token Turnstile e envia."""
    turnstile_input = driver.find_element(By.NAME, "cf-turnstile-response")
    driver.execute_script("arguments[0].value = arguments[1];", turnstile_input, token)

    form = driver.find_element(By.TAG_NAME, "form")
    form.submit()

Desafio Cloudflare - Uso de Cookies

python Copy 
import requests

def access_cloudflare_protected_page(url: str, cf_solution: dict):
    """Use a solução do desafio Cloudflare para acessar a página protegida."""
    session = requests.Session()

    for cookie in cf_solution["cookies"]:
        session.cookies.set(cookie["name"], cookie["value"])

    headers = {"User-Agent": cf_solution["user_agent"]}

    response = session.get(url, headers=headers)
    return response.text

Boas Práticas

1. Tratamento de Erros com Retentativas

python Copy 
from agno.tools import tool
import time

@tool
def solve_with_retry(
    website_url: str,
    website_key: str,
    max_retries: int = 3
) -> str:
    """Resolver CAPTCHA com tentativas automáticas em caso de falha."""
    for attempt in range(max_retries):
        try:
            result = solve_recaptcha_v2(website_url, website_key)
            if not result.startswith("Erro") and not result.startswith("Falha"):
                return result
        except Exception as e:
            if attempt == max_retries - 1:
                return f"Todas as tentativas falharam: {str(e)}"
        time.sleep(2 ** attempt)  # Backoff exponencial

    return "Máximo de tentativas excedido"

2. Gerenciamento de Saldo

python Copy 
@tool
def check_balance() -> float:
    """Verifica o saldo da conta do CapSolver."""
    response = requests.post(
        "https://api.capsolver.com/getBalance",
        json={"clientKey": CAPSOLVER_API_KEY}
    )
    return response.json().get("balance", 0)

3. Suporte Assíncrono

O Agno suporta operações assíncronas para melhor desempenho:

python Copy 
import asyncio
import aiohttp
from agno.tools import tool

@tool
async def solve_captcha_async(website_url: str, website_key: str) -> str:
    """Solucionador de CAPTCHA assíncrono para melhor concorrência."""
    async with aiohttp.ClientSession() as session:
        payload = {
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteURL": website_url,
                "websiteKey": website_key
            }
        }

        async with session.post(
            "https://api.capsolver.com/createTask",
            json=payload
        ) as response:
            result = await response.json()

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

        task_id = result.get("taskId")

        for _ in range(60):
            await asyncio.sleep(2)

            async with session.post(
                "https://api.capsolver.com/getTaskResult",
                json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
            ) as response:
                result = await response.json()

            if result.get("status") == "ready":
                solution = result.get("solution", {})
                return solution.get("gRecaptchaResponse") or solution.get("token")
            if result.get("status") == "failed":
                return f"Falha: {result.get('errorDescription')}"

        return "Tempo esgotado"

Conclusão

A integração do CapSolver com o Agno libera o potencial total de agentes de IA autônomos para tarefas baseadas na web. Combinando a orquestração multiagente rápida e de privacidade do Agno com as capacidades líderes de resolução de CAPTCHA do CapSolver, os desenvolvedores podem construir soluções de automação robustas que lidam com até os mecanismos de proteção da web mais desafiadores.

Seja para construir pipelines de extração de dados, frameworks de testes automatizados ou agentes inteligentes da web, a combinação Agno + CapSolver fornece a velocidade, confiabilidade e escalabilidade necessárias para ambientes de produção.

Pronto para começar? Inscreva-se no CapSolver e use o código de bônus AGNO para obter um bônus adicional de 6% na primeira recarga!

Perguntas Frequentes

O que é Agno?

O Agno é um framework, runtime e plano de controle multiagente para construir produtos de IA. Ele é 529× mais rápido que o LangGraph com 24× menor uso de memória e roda inteiramente em sua infraestrutura para máxima privacidade.

Como o CapSolver se integra com o Agno?

O CapSolver se integra com o Agno por meio de ferramentas personalizadas decoradas com @tool. Você cria funções que envolvem a API do CapSolver, permitindo que seus agentes de IA resolvam desafios CAPTCHA automaticamente quando encontrá-los durante as operações da web.

Quais tipos de CAPTCHAs o CapSolver pode resolver?

O CapSolver suporta uma ampla gama de tipos de CAPTCHA, incluindo reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, Cloudflare Challenge, AWS WAF, GeeTest e muitos outros.

Quanto custa o CapSolver?

O CapSolver oferece preços competitivos com base no tipo e volume de CAPTCHAs resolvidos. Visite capsolver.com para detalhes sobre os preços atuais. Use o código AGNO para obter um bônus de 5% na primeira recarga.

Posso usar o Agno com diferentes provedores de LLM?

Sim! O Agno é independente de modelo e suporta mais de 50 provedores de modelos, incluindo OpenAI, Anthropic Claude, Google Gemini, Groq e muitos outros.

O Agno é gratuito para uso?

Sim, o Agno é de código aberto e licenciado sob MIT. O framework é gratuito para uso, embora você possa incorrer em custos com chamadas de API de LLM e serviços de resolução de CAPTCHA, como o CapSolver.

Como encontrar a chave do site do CAPTCHA?

A chave do site geralmente é encontrada no código fonte da página. Procure por:

  • reCAPTCHA: atributo data-sitekey ou chamada grecaptcha.render()
  • Turnstile: atributo data-sitekey no widget Turnstile

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

Resolvendo Erros 403 Proibidos ao Raspar Sites com Python
Resolvendo Erros 403 Proibidos ao Raspar Sites com Python

Aprenda como superar erros 403 Proibido ao raspar sites com Python. Este guia aborda rotação de IPs, falsificação de user-agent, limitação de requisições, gerenciamento de autenticação e uso de navegadores headless para contornar restrições de acesso e continuar raspando sites com sucesso.

web scraping
Logo of CapSolver

Emma Foster

13-Jan-2026

Agno com Integração CapSolver
Como resolver CAPTCHA no Agno com integração do CapSolver

Aprenda como integrar o CapSolver com o Agno para resolver desafios de reCAPTCHA v2/v3, Cloudflare Turnstile e WAF em agentes de IA autônomos. Inclui exemplos reais de Python para raspagem de web e automação.

web scraping
Logo of CapSolver

Adélia Cruz

13-Jan-2026

Como resolver CAPTCHA com o Katana usando o CapSolver
Integração do Katana com o CapSolver: Resolução Automática de CAPTCHA para Web Crawling

Aprenda como integrar o Katana com o Capsolver para resolver automaticamente o reCAPTCHA v2 e o Cloudflare Turnstile em raspagem sem cabeça.

web scraping
Logo of CapSolver

Adélia Cruz

12-Jan-2026

Melhores Bibliotecas de Web Scraping em Python 2026
Melhores Bibliotecas de Web Scraping 2026

Descubra as melhores bibliotecas de raspagem de web em Python para 2026. Compare funcionalidades, facilidade de uso e desempenho para suas necessidades de extração de dados. Inclui perspectivas de especialistas e Perguntas Frequentes.

web scraping
Logo of CapSolver

Rajinder Singh

12-Jan-2026

Como resolver Captcha com Crawlab usando CapSolver
Integração do Crawlab com o CapSolver: Resolução Automatizada de CAPTCHA para Raspagem Distribuída

Aprenda como integrar o CapSolver com o Crawlab para resolver reCAPTCHA e Cloudflare Turnstile em escala.

web scraping
Logo of CapSolver

Adélia Cruz

09-Jan-2026

Os Melhores Ferramentas de Raspagem de IA que Você Precisa Conhecer em 2026
Sample Post

Descubra as melhores opções de ferramentas de raspagem de IA para 2026. Comparamos as principais ferramentas de raspagem web de IA, incluindo Bright Data, Crawl4AI e Browse AI, com preços específicos para ajudar você a dominar a extração de dados automatizada e a resolução de desafios de segurança.

web scraping
Logo of CapSolver

Emma Foster

07-Jan-2026