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

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

Adélia Cruz

Neural Network Developer

13-Jan-2026

À 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

reCAPTCHA v2 (Imagem e Invisível)
reCAPTCHA v3
Cloudflare Turnstile
Desafio Cloudflare (5s)
AWS WAF
E muitos mais...

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:

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.
Privacidade Preservada: Tanto o Agno quanto o CapSolver permitem que você mantenha o controle sobre seus dados
Automação Escalável: Lidar com múltiplos desafios de CAPTCHA em operações de agentes concorrentes
Custo Eficiente: Pague apenas pelos CAPTCHAs resolvidos com sucesso
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

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

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

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

Adélia Cruz

26-Jan-2026

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

Adélia Cruz

21-Jan-2026

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

Adélia Cruz

21-Jan-2026

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

Adélia Cruz

16-Jan-2026