CAPSOLVER
Blog
All
Como integrar CapSolver com o Selenium | Guia Completo 2025

Como Integrar CapSolver com Selenium | Guia Completo 2025

Logo of CapSolver

Adélia Cruz

Neural Network Developer

04-Sep-2025

O que é o Selenium?

O Selenium é uma ferramenta de teste de automação de código aberto, usada principalmente para automatizar aplicações web. Também é comumente usada para raspagem de dados da web e automação de interações em sites. O Selenium pode simular diversos comportamentos de usuários em um navegador, como cliques, digitação, rolagem e navegação entre páginas. Foi originalmente desenvolvido por Jason Huggins em 2004 e agora é mantido pela equipe do projeto Selenium. O Selenium suporta várias linguagens de programação, incluindo Python, Java, C#, Ruby e JavaScript.

O Selenium consiste nos seguintes componentes principais:

  1. Selenium WebDriver (mais comumente usado)

    • Oferece controle nativo sobre o navegador, suportando navegadores principais como Chrome, Firefox, Edge e Safari.
    • Pode simular várias ações do navegador, como cliques, digitação, rolagem e troca de guias.
    • Cada navegador possui um driver correspondente, como chromedriver ou geckodriver.

  2. Selenium IDE

    • Uma extensão do navegador (para Chrome/Firefox) que permite gravar e reproduzir scripts de teste. É ideal para iniciantes em testes.

  3. Selenium Grid

    • Permite testes distribuídos formando uma rede de testes com múltiplos navegadores e máquinas, permitindo a execução paralela de scripts.

Casos de uso comuns

  • Raspagem de conteúdo dinâmico: Extrair dados gerados pelo renderização de JavaScript.
  • Manipulação de interações complexas: Adequado para raspagem de sites que exigem login ou ações em múltiplas etapas para acessar dados.
  • Extração de dados de aplicações SPA: Navegar por páginas construídas com frameworks como Vue ou React.
  • Testes automatizados: Validar a funcionalidade da página enquanto coleta dados simultaneamente.
  • Trabalho no modo headless: Realizar todas as operações sem uma interface gráfica, ideal para execução em servidores.

Uso Básico do Selenium

Para usar o Selenium no Python:

bash Copy 
pip install selenium

Para usar o Selenium com o Chrome, baixe o chromedriver que corresponda à sua versão do Chrome no Github

Exemplo: Usar o Selenium para obter todos os títulos dos posts do blog da CapSolver:

python Copy 
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Especificar o caminho do chromedriver (se já estiver no PATH, pode ser omitido)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

try:
    driver.get("https://www.capsolver.com/blog/All")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, 'h5')))

    h5_elements = driver.find_elements(By.TAG_NAME, "h5")
    for el in h5_elements:
        print(el.text.strip())

finally:
    driver.quit()

Como Integrar a Extensão CapSolver com o Selenium

O Selenium é uma ferramenta poderosa que suporta o carregamento de extensões de navegador, assim como um navegador regular.

  1. Baixe o pacote .zip mais recente da extensão na página oficial do CapSolver no GitHub e descompacte-o:
    👉 https://github.com/capsolver/capsolver-browser-extension/releases

  2. Nas opções de inicialização do Selenium, use o argumento load-extension para especificar o caminho da extensão:

python Copy 
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")
chrome_options.add_argument("load-extension=/path/to/capSolver extension")

# Especificar o caminho do chromedriver (omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

try:
    driver.get("https://www.capsolver.com/blog/All")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, 'h5')))

    h5_elements = driver.find_elements(By.TAG_NAME, "h5")
    for el in h5_elements:
        print(el.text.strip())

finally:
    driver.quit()

⚠️ Importante: A partir da versão Chrome 137, a automação do navegador pode falhar ao carregar extensões, a menos que você adicione manualmente o seguinte argumento.
Sem esse sinalizador, resolver CAPTCHAs por meio de extensões não funcionará no Chrome 137+：

python Copy 
chrome_options.add_argument("--disable-features=DisableLoadExtensionCommandLineSwitch")

Mais detalhes: SeleniumHQ. Versões diferentes podem se comportar de forma diferente — ajuste de acordo com o seu ambiente.

Usando a Extensão CapSolver para Resolver reCAPTCHA v2

CAPTCHAs como reCAPTCHA, Cloudflare Turnstile, AWS WAF e GeeTest são amplamente usados em milhares de sites. No entanto, suas estruturas DOM permanecem basicamente consistentes entre os sites. A Extensão CapSolver pode detectar e resolver automaticamente esses CAPTCHAs com base em suas características distintas — sem necessidade de interação manual.

Vamos usar o reCAPTCHA v2 como exemplo e demonstrar como usar a Extensão CapSolver dentro do Selenium para contorná-lo.
(Obs: a menos que seja informado o contrário, o seguinte exemplo usa o modo click: definido em /assets/config.js → reCaptchaMode: 'click')

🛠️ Não se esqueça de descompactar a extensão e configurar seu apiKey em /assets/config.js

python Copy 
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Etapa 1: Obtenha a extensão do GitHub: https://github.com/capsolver/capsolver-browser-extension/releases
# Etapa 2: Descompacte a extensão e defina seu apiKey em /assets/config.js
chrome_options.add_argument("load-extension=/path/to/CapSolver Browser Extension-v1.16.0")

# Especificar o caminho do chromedriver (omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

try:
    driver.get("https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, 'form[action="/recaptcha-v2-checkbox.php"]')))

    # A extensão detectará e resolverá automaticamente o reCAPTCHA
    time.sleep(15)

    # Após resolver, clique no botão de submissão
    submit_button = driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]')
    submit_button.click()
    time.sleep(3)

except Exception as error:
    print(error)

finally:
    driver.quit()

A Extensão CapSolver também suporta muitas opções de configuração úteis. Todos os ajustes podem ser modificados no arquivo /assets/config.js.

Opção de Configuração solvedCallback

No exemplo anterior, esperamos 15 segundos após o carregamento da página antes de clicar no botão de submissão. Esse período de espera foi intencionalmente definido para dar à extensão CapSolver tempo suficiente para resolver automaticamente o reCAPTCHA.
No entanto, esse método não é elegante. Na prática, resolver o CAPTCHA pode levar muito menos de 15 segundos, ou em casos de rede lenta, mais de 15 segundos.

Para resolver isso, o CapSolver fornece uma opção de configuração chamada solvedCallback. Isso permite definir uma função de retorno que é acionada quando o CAPTCHA for resolvido com sucesso. Você pode encontrar a opção solvedCallback em /assets/config.js, e pode personalizar o nome da função — por padrão, é captchaSolvedCallback.

Se você estiver usando Puppeteer ou Playwright, pode expor essa função de retorno ao contexto do navegador usando o método page.exposeFunction. Veja:

E o que dizer do Python + Selenium?

Infelizmente, o Selenium do Python não fornece um equivalente embutido para page.exposeFunction, então a funcionalidade solvedCallback não pode ser totalmente utilizada nesse ambiente.

Em vez disso, recomendamos usar observação do DOM para determinar se o CAPTCHA foi resolvido. Por exemplo, você pode verificar se a caixa de seleção "I'm not a robot" desapareceu ou se tornou um marcador de verificação (✔), indicando que a validação foi concluída.

Vamos melhorar o exemplo anterior usando essa estratégia:

python Copy 
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Etapa 1: Obtenha a extensão do GitHub: https://github.com/capsolver/capsolver-browser-extension/releases
# Etapa 2: Descompacte a extensão e defina seu apiKey em /assets/config.js
chrome_options.add_argument("load-extension=/path/to/CapSolver Browser Extension-v1.16.0")

# Especificar o caminho do chromedriver (omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

def check_recaptcha_status(driver):
    try:
        iframe = driver.find_element(By.CSS_SELECTOR, 'iframe[src*="recaptcha"]')
        driver.switch_to.frame(iframe)

        # Verifique se o nome da classe indica que a caixa de seleção foi marcada
        recaptcha_anchor = driver.find_element(By.ID, "recaptcha-anchor")
        class_list = recaptcha_anchor.get_attribute("class")
        driver.switch_to.default_content()
        if "recaptcha-checkbox-checked" in class_list.split():
            return True
        else:
            return False
    except Exception as e:
        print(f"Falha ao verificar o status do reCAPTCHA: {e}")
        driver.switch_to.default_content()
        return False

try:
    driver.get("https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, 'form[action="/recaptcha-v2-checkbox.php"]')))
    
    # A extensão reconhecerá e resolverá o CAPTCHA automaticamente.
    # Em vez de dormir por um tempo fixo, verifique periodicamente.
    timeout = 30
    start_time = time.time()
    while time.time() - start_time < timeout:
        if check_recaptcha_status(driver):
            print("Verificação do reCAPTCHA bem-sucedida!")
            submit_button = driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]')
            submit_button.click()
            time.sleep(3)
            driver.quit()
            break
        time.sleep(1)

except Exception as error:
    print(error)

finally:
    driver.quit()

Opção de Configuração manualSolving

Nos exemplos anteriores, o processo de resolução do CAPTCHA começa automaticamente assim que a página termina de carregar. No entanto, em alguns casos, você pode precisar realizar outras ações primeiro — como preencher um nome de usuário e senha — antes de disparar o solucionador do CAPTCHA. Resolver o CAPTCHA muito cedo pode resultar em o token expirar antes da submissão.

A opção manualSolving foi criada para resolver esse problema. Ao definir manualSolving: true em /assets/config.js, você pode ativar manualmente a resolução do CAPTCHA usando um dos seguintes métodos:

  1. Simular um clique no botão da extensão CapSolver via Selenium.
  2. Executar um script para enviar uma mensagem: window.postMessage({ type: 'capsolverSolve' });
    (Nota: esse método é suportado nas versões da extensão v1.16.0 e superiores.)

O exemplo a seguir demonstra como usar ambos os métodos:

python Copy 
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Etapa 1: Obtenha a extensão do GitHub (https://github.com/capsolver/capsolver-browser-extension/releases)
# Etapa 2: Descompacte a extensão e configure seu apiKey em /assets/config.js
chrome_options.add_argument("load-extension=/path/to/CapSolver Browser Extension-v1.16.0")

# Especificar o caminho do chromedriver (omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

def check_recaptcha_status(driver):
    try:
        iframe = driver.find_element(By.CSS_SELECTOR, 'iframe[src*="recaptcha"]')
        driver.switch_to.frame(iframe)

        # Determine se a caixa de seleção foi marcada
        recaptcha_anchor = driver.find_element(By.ID, "recaptcha-anchor")
        class_list = recaptcha_anchor.get_attribute("class")
        driver.switch_to.default_content()
        if "recaptcha-checkbox-checked" in class_list.split():
            return True
        else:
            return False
    except Exception as e:
        print(f"Falha ao verificar o status do reCAPTCHA: {e}")
        driver.switch_to.default_content()
        return False

try:
    driver.get("https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, 'form[action="/recaptcha-v2-checkbox.php"]')))

    # Simular entrada do usuário
    driver.execute_script("""
        const inputA = document.querySelector('input[name="ex-a"]');
        inputA.value = 'username';
        const inputB = document.querySelector('input[name="ex-b"]');
        inputB.value = 'password';
    """)

    # Simular operações adicionais
    for i in range(1, 6):
        time.sleep(1)
        print(f"Esperou {i} segundos...")

    # Disparar a resolução do CAPTCHA (manualSolving deve ser definido como true em config.js)
    print("Iniciando a resolução do CAPTCHA...")

    # Método 1: Simular o clique no botão da CapSolver
    try:
        capsolver_button = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "#capsolver-solver-tip-button")))
        driver.execute_script("arguments[0].click();", capsolver_button)
    except Exception as e:
        print(f"Não foi possível encontrar o botão da CapSolver: {e}")

    # Método 2: Disparar via postMessage (método alternativo)
# driver.execute_script("window.postMessage({ type: 'capsolverSolve' });")

    # Aguarde a resolução do CAPTCHA e envie o formulário
    timeout = 30
    start_time = time.time()
    while time.time() - start_time < timeout:
        if check_recaptcha_status(driver):
            print("Verificação reCAPTCHA bem-sucedida!")
            submit_button = driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]')
            submit_button.click()
            time.sleep(3)
            driver.quit()
            break
        time.sleep(1)

except Exception as error:
    print(error)

finally:
    driver.quit()

Configuração de reCaptchaMode

reCaptchaMode suporta dois modos: click e token.

  • click: Simula um humano clicando nos desafios de imagem.
  • token: Pula qualquer clique e envia diretamente a tarefa para o backend do CapSolver via API, retornando um token uma vez que o CAPTCHA seja resolvido.

Se você notar que o modo click requer múltiplas rodadas de desafios de imagem, isso provavelmente indica um ambiente local de baixa qualidade. Nesse caso, é recomendado usar o modo token para melhor desempenho.

Modo Click Modo Token

Configuração de showSolveButton

Quando você define showSolveButton: false (o padrão é true), o botão de resolução do CapSolver não aparecerá na página.
No entanto, isso não afeta a funcionalidade de resolução de CAPTCHA — ele ainda funcionará normalmente em segundo plano.

Configuração de useProxy

Após habilitar useProxy: true, você pode especificar as seguintes configurações de proxy:

  • proxyType
  • hostOrIp
  • port
  • proxyLogin
  • proxyPassword

Então usaremos seu proxy personalizado para resolver o CAPTCHA.

Quando você deve usar seu próprio proxy? Aqui estão duas cenas comuns:

  1. Seu proxy oferece melhor qualidade (por exemplo, gera uma pontuação mais alta para tokens reCAPTCHA) ou velocidade de resolução mais rápida.
  2. Em alguns casos, o IP usado para resolver o CAPTCHA deve corresponder ao IP usado para enviar o token, o que exige o uso do seu proxy.

Essas são algumas opções de configuração comumente usadas. Você pode ajustar outras configurações de acordo com suas necessidades reais. Se tiver alguma dúvida, entre em contato com nosso suporte ao cliente.

Resolvendo ImageToText com a Extensão CapSolver

Ao contrário de terceiros CAPTCHAs como reCAPTCHA, Cloudflare Turnstile, AWS WAF, há outra categoria de CAPTCHA que requer reconhecer letras ou números em uma imagem — referimos a esses como CAPTCHAs ImageToText. Eles normalmente se parecem com isso:

CAPTCHAs ImageToText são normalmente implementações personalizadas pelos proprietários do site. Como a localização desses CAPTCHAs varia entre diferentes sites e páginas, a Extensão CapSolver não pode automaticamente detectar quais imagens são CAPTCHAs. Você precisa indicar manualmente isso no seu código.

Aqui está como você faz isso:

  1. Adicione o atributo capsolver-image-to-text-source (valor 0) ao elemento da imagem do CAPTCHA.
  2. Adicione o atributo capsolver-image-to-text-result (valor 0) ao campo de entrada do resultado.

Ambos os atributos capsolver-image-to-text-source e capsolver-image-to-text-result podem ser configurados em /assets/config.js, nas opções textCaptchaSourceAttribute e textCaptchaResultAttribute, respectivamente.

Vamos usar demo como exemplo, e mostrar como resolver um CAPTCHA ImageToText usando Selenium:

Da fonte da página, identificamos:

  • ID do elemento da imagem do CAPTCHA: demoCaptcha_CaptchaImage
  • ID do campo de entrada do resultado: captchaCode

Assim:

Agora podemos adicionar os atributos necessários usando o método setAttribute no nosso script Selenium:

python Copy 
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Etapa 1: Obtenha a extensão do GitHub (https://github.com/capsolver/capsolver-browser-extension/releases)
# Etapa 2: Descompacte o arquivo zip da extensão e configure sua apiKey em /assets/config.js
chrome_options.add_argument("load-extension=/path/to/CapSolver Browser Extension-v1.16.0")

# Especifique o caminho do chromedriver (pode omitir se adicionado ao PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

try:
    driver.get("https://captcha.com/demos/features/captcha-demo.aspx")
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#demoCaptcha_CaptchaImage')))

    # Informe à extensão CapSolver onde está a imagem do CAPTCHA
    driver.execute_script("""
        const imgElement = document.querySelector('#demoCaptcha_CaptchaImage');
        if (imgElement) {
            imgElement.setAttribute('capsolver-image-to-text-source', '0');
        }
    """)

    # Informe à extensão CapSolver onde o resultado da reconhecimento deve ser inserido
    driver.execute_script("""
        const resultElement = document.querySelector('#captchaCode');
        if (resultElement) {
            resultElement.setAttribute('capsolver-image-to-text-result', '0');
        }
    """)

    time.sleep(5)
    validate_button = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'validateCaptchaButton')))
    validate_button.click()
    time.sleep(5)

except Exception as error:
    print(error)

finally:
    driver.quit()

Resultado esperado:

Como Integrar a API CapSolver com Selenium

Usar a extensão CapSolver é conveniente e rápido. No entanto, se você é um desenvolvedor experiente, recomendamos usar o método de API em vez disso. Comparado com a integração baseada em extensão, a abordagem de API tem várias vantagens:

  1. Você pode personalizar mais parâmetros, e a entrada é mais precisa — capaz de lidar com praticamente todos os cenários de CAPTCHA.
  2. Você tem maior controle sobre quando o CAPTCHA é resolvido.
  3. A API fornece mensagens de erro mais detalhadas, ajudando você a otimizar sua lógica efetivamente.

Antes de Começar

Você precisará entender como usar a API CapSolver. O processo envolve dois passos:

  • Passo 1: Crie uma tarefa via https://api.capsolver.com/createTask
  • Passo 2: Obtenha o resultado via https://api.capsolver.com/getTaskResult

Ao criar uma tarefa, você precisa enviar um payload JSON para o CapSolver, que normalmente inclui parâmetros como sua clientKey, websiteURL, websiteKey, etc. Esses parâmetros variam dependendo do tipo de CAPTCHA e do site-alvo. Para detalhes completos, consulte nossa documentação

Resolvendo reCAPTCHA v2 com a API CapSolver

Antes de resolver reCAPTCHA v2, consulte o guia:
👉 https://docs.capsolver.com/en/guide/captcha/ReCaptchaV2/
Ele explica exatamente quais campos JSON incluir em sua solicitação.

Além disso, você pode usar a extensão CapSolver para extrair rapidamente os dados JSON necessários. Veja este blog para ajuda:
🔗 obter os dados JSON

Vamos usar o seguinte exemplo: https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php,
O payload JSON necessário é:

json Copy 
{
    "type": "ReCaptchaV2TaskProxyLess",
    "websiteKey": "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
    "websiteURL": "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
}

Também fornecemos amostras de código Python para usar a API em nossa documentação:

Exemplo: Integrando com Selenium (Python)

python Copy 
import time
import requests
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Especifique o caminho do chromedriver (pode omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

# TODO: Configure suas configurações do CapSolver
api_key = "SUA_API_KEY"  # Substitua pela sua chave de API do CapSolver
site_key = "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9"  # Chave do site reCAPTCHA
site_url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"  # URL da página-alvo
captcha_type = 'ReCaptchaV2TaskProxyLess'

def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": captcha_type,
            "websiteKey": site_key,
            "websiteURL": site_url
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    task_id = resp.get("taskId")
    if not task_id:
        print("Falha ao criar tarefa:", res.text)
        return ""
    print(f"Obtido taskId: {task_id} / Obtendo resultado...")

    while True:
        time.sleep(1)
        payload = {"clientKey": api_key, "taskId": task_id}
        res = requests.post("https://api.capsolver.com/getTaskResult", json=payload)
        resp = res.json()
        status = resp.get("status")
        if status == "ready":
            return resp.get("solution", {}).get('gRecaptchaResponse')
        if status == "failed" or resp.get("errorId"):
            print("Falha na resolução! resposta:", res.text)
            return ""

try:
    token = capsolver()
    print("token:", token)

    driver.get(site_url)
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, 'form[action="/recaptcha-v2-checkbox.php"]')))

    # Injeta o token de resposta do reCAPTCHA
    driver.execute_script("""
        const textarea = document.getElementById('g-recaptcha-response');
        if (textarea) {
            textarea.value = arguments[0];
        }
    """, token)

    # Clique no botão de envio
    submit_button = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'button[type="submit"]')))
    submit_button.click()
    time.sleep(5)

except Exception as error:
    print(error)

finally:
    driver.quit()

Resolvendo ImageToText com a API CapSolver

Vamos continuar usando o site de exemplo: https://captcha.com/demos/features/captcha-demo.aspx.
Nesta página, o elemento da imagem do CAPTCHA tem o ID demoCaptcha_CaptchaImage, e o campo de entrada do resultado tem o ID `captchaCode", como mostrado na imagem abaixo:

Em uma ImageToTextTask, precisamos passar o valor codificado em base64 da imagem do CAPTCHA para o CapSolver. Aqui está um exemplo funcional:

python Copy 
import time
import requests
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")

# Especifique o caminho do chromedriver (pode omitir se já estiver no PATH)
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

# TODO: Defina sua configuração do CapSolver
api_key = "SUA_API_KEY"  # Substitua pela sua chave de API do CapSolver
site_url = "https://captcha.com/demos/features/captcha-demo.aspx"  # URL da página-alvo
captcha_type = 'ImageToTextTask'

def capsolver(base64Image):
    payload = {
        "clientKey": api_key,
        "task": {
            "type": captcha_type,
            "websiteURL": site_url,
            "body": base64Image
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    status = resp.get("status")
    if status == "ready":
        return resp.get("solution", {}).get('text')
    elif status == "failed" or resp.get("errorId"):
        print("Falha na resolução! resposta:", res.text)
        return ""
    else:
        print("Resposta desconhecida:", resp.text)
        return ""

try:
    driver.get(site_url)
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#demoCaptcha_CaptchaImage')))

    # Recupere a string base64 da atributo src da imagem do captcha
    captcha_src = driver.execute_script("""
        const img = document.querySelector('img[id="demoCaptcha_CaptchaImage"]');
        return img ? img.getAttribute('src') : null;
    """)

    if not captcha_src:
        raise Exception("Não foi possível obter a imagem do captcha!")

    base64_image = captcha_src.split(',')[1]  # Remova o prefixo 'data:image/png;base64,'
    captcha_text = capsolver(base64_image)
    print("Texto:", captcha_text)

    # Preencha o resultado do CAPTCHA
    driver.execute_script("""
        document.getElementById('captchaCode').value = arguments[0];
    """, captcha_text)

    # Clique no botão de validação
    validate_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, '#validateCaptchaButton'))
    )
    validate_button.click()
    time.sleep(5)

except Exception as error:
    print(error)

finally:
    driver.quit()

Para certos tipos de CAPTCHAs ImageToText complexos, você pode especificar diferentes modelos de reconhecimento para melhorar a precisão. Para mais detalhes, consulte a documentação oficial:
👉 https://docs.capsolver.com/en/guide/recognition/ImageToTextTask/

Como Integrar o SDK CapSolver com Selenium

A CapSolver fornece SDKs oficiais para o Python e o Golang, que permitem integrar a resolução de CAPTCHA com esforço mínimo. Ao contrário do uso da API bruta (onde você deve lidar manualmente com createTask e getTaskResult), os SDKs simplificam todo o processo.

Repositórios oficiais do GitHub:

Resolvendo reCAPTCHA v2 com o SDK da CapSolver

Assim como com a API, antes de resolver o reCAPTCHA v2, você deve consultar a documentação para obter informações detalhadas sobre quais parâmetros JSON enviar:
🔗 https://docs.capsolver.com/en/guide/captcha/ReCaptchaV2/
Além disso, você pode usar a extensão do CapSolver para extrair rapidamente os dados JSON necessários:
🔗 https://www.capsolver.com/blog/reCAPTCHA/recaptcha-v3-solver-human-score

Vamos usar esta página como exemplo:
👉 https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php

O payload JSON necessário é o seguinte:

json Copy 
{
  "type": "ReCaptchaV2TaskProxyLess",
  "websiteKey": "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
  "websiteURL": "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
}

Instale o SDK da CapSolver:

bash Copy 
pip install capsolver

Exemplo: Usando o SDK no Selenium

python Copy 
import time
import capsolver
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

# Defina sua configuração da CapSolver
api_key = "SUA_CHAVE_DE_API"
site_key = "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9"
site_url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
captcha_type = 'ReCaptchaV2TaskProxyLess'
capsolver.api_key = api_key

try:
    # Resolver usando o SDK
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": site_url,
        "websiteKey": site_key,
    })
    token = solution["gRecaptchaResponse"]
    print("token:", token)

    driver.get(site_url)
    WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, 'form[action="/recaptcha-v2-checkbox.php"]'))
    )

    driver.execute_script("""
        const textarea = document.getElementById('g-recaptcha-response');
        if (textarea) {
            textarea.value = arguments[0];
        }
    """, token)

    submit_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, 'button[type="submit"]'))
    )
    submit_button.click()
    time.sleep(5)

except Exception as error:
    print(error)

finally:
    driver.quit()

Resolvendo ImageToText com o SDK da CapSolver

Assim como com a API, continuaremos com o site:
👉 https://captcha.com/demos/features/captcha-demo.aspx
A imagem CAPTCHA tem o ID demoCaptcha_CaptchaImage, e o campo de entrada do resultado tem o ID captchaCode.

Em uma tarefa ImageToTextTask, basta passar a imagem codificada em base64 para a CapSolver.

Código de exemplo:

python Copy 
import time
import capsolver
import requests
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

chrome_options = Options()
chrome_options.add_argument("--start-maximized")
service = Service(executable_path="chromedriver.exe")
driver = webdriver.Chrome(options=chrome_options, service=service)

# Defina sua configuração da CapSolver
api_key = "SUA_CHAVE_DE_API"
site_url = "https://captcha.com/demos/features/captcha-demo.aspx"
captcha_type = 'ImageToTextTask'
capsolver.api_key = api_key

try:
    driver.get(site_url)
    WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, '#demoCaptcha_CaptchaImage'))
    )

    # Obtenha a string base64 da imagem
    captcha_src = driver.execute_script("""
        const img = document.querySelector('img[id="demoCaptcha_CaptchaImage"]');
        return img ? img.getAttribute('src') : null;
    """)
    if not captcha_src:
        raise Exception("Não foi possível obter a imagem do CAPTCHA!")

    base64_image = captcha_src.split(',')[1]
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": site_url,
        "body": base64_image,
    })
    captcha_text = solution["text"]
    print("Texto:", captcha_text)

    driver.execute_script("""
        document.getElementById('captchaCode').value = arguments[0];
    """, captcha_text)

    validate_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, '#validateCaptchaButton'))
    )
    validate_button.click()
    time.sleep(5)

except Exception as error:
    print(error)

finally:
    driver.quit()

Referências Úteis

Vídeos de demonstração com a Extensão do CapSolver:

Além disso, a CapSolver oferece um Programa de Compartilhamento de Receita para Desenvolvedores, que permite que desenvolvedores e parceiros ganhem comissões ao integrar ou promover soluções da CapSolver. É uma ótima maneira de monetizar seu trabalho enquanto ajuda outros a resolver CAPTCHAS de forma eficiente. Para mais detalhes, consulte:
Plano de Desenvolvedor da CapSolver

Conclusão

Este guia mostrou como integrar efetivamente o Selenium com a CapSolver para lidar com CAPTCHAS. Cobrimos os recursos principais do Selenium para automação web e destacamos dois métodos principais de integração com a CapSolver:

  1. A Extensão do CapSolver: Uma solução direta para resolução automática de CAPTCHA, ótima para configurações rápidas.
  2. A API/SDK da CapSolver: Oferece mais controle e precisão, ideal para casos de uso avançados. Você pode encontrar a documentação da API detalhada aqui e o SDK do Python aqui.

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

Errore 1006, 1007, 1008 do Cloudflare
Erro do Cloudflare 1006, 1007, 1008 Solução para Resolver | Como Corrigir

Lidando com erros do Cloudflare 1006, 1007 ou 1008? Aprenda soluções práticas para resolver esses bloqueios de acesso e melhorar sua experiência de crawling na web.

Cloudflare
Logo of CapSolver

Anh Tuan

05-Dec-2025

Como resolver captchas ao fazer web scraping com Scrapling e CapSolver
Como resolver captchas ao realizar web scraping com o Scrapling e o CapSolver

Scrapling + CapSolver permite raspagem automatizada com ReCaptcha v2/v3 e Cloudflare Turnstile bypass.

web scraping
Logo of CapSolver

Aloísio Vítor

05-Dec-2025

Alterar o Agente de Usuário no Selenium
Alterar o User-Agent no Selenium | Passos & Boas Práticas

Alterar o Agente de Usuário no Selenium é um passo crucial para muitas tarefas de raspagem da web. Ajuda a disfarçar o script de automação como um navegador regular...

The other captcha
Logo of CapSolver

Emma Foster

05-Dec-2025

Como identificar se `action` é necessário para resolver o Cloudflare Turnstile usando a extensão CapSolver
Como identificar se `action` é necessário para resolver o Cloudflare Turnstile usando a extensão CapSolver

Aprenda a identificar ações para resolução eficaz de captchas cloudflare turnstile. Siga nosso guia passo a passo sobre o uso das ferramentas e técnicas do Capsolver.

Cloudflare
Logo of CapSolver

Aloísio Vítor

05-Dec-2025

9proxy
Descubra o Poder do 9Proxy: Uma Revisão Abrangente

Neste artigo, vamos mostrar a você o que é 9proxy e os serviços que eles oferecem.

Partners
Logo of CapSolver

Ethan Collins

04-Dec-2025

Raspagem de Web com Selenium e Python
Web Scraping com Selenium e Python | Resolvendo Captcha Ao Fazer Web Scraping

Neste artigo, você vai se familiarizar com a raspagem de dados da web usando o Selenium e o Python, e aprender a resolver o Captcha envolvido no processo para uma extração de dados eficiente.

web scraping
Logo of CapSolver

Anh Tuan

04-Dec-2025