
Sora Fujimoto
AI Solutions Architect

CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart) é uma medida de segurança projetada para distinguir usuários humanos de bots automatizados. Ele geralmente apresenta desafios como reconhecimento de imagens, distorção de texto ou quebra-cabeças interativos que são fáceis para humanos, mas difíceis para bots. Embora os CAPTCHAs protejam sites contra abuso automatizado, eles podem ser um grande obstáculo para automação legítima e atividades de raspagem de web.
Neste blog, exploraremos como resolver CAPTCHAs usando o Playwright com a extensão CapSolver. Além disso, olharemos para a resolução do reCAPTCHA usando a API CapSolver com Python e Go.
CAPTCHA é um mecanismo de segurança usado por sites para impedir o acesso automatizado e garantir que o usuário seja humano. Tipos comuns incluem:
CapSolver é uma ferramenta poderosa projetada para resolver automaticamente vários tipos de CAPTCHAs, incluindo captcha e reCAPTCHA. Ele fornece extensões de navegador e APIs para integração sem problemas em seus fluxos de automação da web.
Resgate seu código promocional CapSolver
Aumente seu orçamento de automação instantaneamente!
Use o código promocional CAPN ao recarregar sua conta do CapSolver para obter um bônus extra de 5% em cada recarga — sem limites.
Resgate-o agora em seu Painel CapSolver
.
Primeiro, você precisa instalar o Playwright. Você pode fazer isso via npm:
npm install playwright
./CapSolver.Browser.Extension no diretório raiz do seu projeto../assets/config.json. Certifique-se de que enabledForcaptcha esteja definido como true e defina captchaMode como token para resolução automática.Exemplo de alteração de configuração:
{
"enabledForcaptcha": true,
"captchaMode": "token"
}
Abaixo está um exemplo de script usando o Playwright para resolver captcha com a extensão CapSolver:
const { chromium } = require('playwright');
const path = require('path');
(async () => {
const extensionPath = path.join(__dirname, 'CapSolver.Browser.Extension');
const browser = await chromium.launchPersistentContext('', {
headless: false,
args: [
`--disable-extensions-except=${extensionPath}`,
`--load-extension=${extensionPath}`
]
});
const page = await browser.newPage();
await page.goto('https://site.example');
// Localize a caixa de seleção do captcha ou o quadro e interaja conforme necessário
await page.waitForSelector('selector-for-captcha', { state: 'visible' });
await page.click('selector-for-captcha');
// Adicione etapas adicionais conforme necessário
// ...
await browser.close();
})();
Para reCAPTCHA, você pode usar a API CapSolver. Aqui estão exemplos em Python e Go.
import requests
import time
api_key = "SUA_CHAVE_DE_API"
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
site_url = "https://www.google.com/recaptcha/api2/demo"
def capsolver():
payload = {
"clientKey": api_key,
"task": {
"type": 'ReCaptchaV2TaskProxyLess',
"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(3)
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 ao resolver! resposta:", res.text)
return
token = capsolver()
print(token)
package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"time"
)
type capSolverResponse struct {
ErrorId int32 `json:"errorId"`
ErrorCode string `json:"errorCode"`
ErrorDescription string `json:"errorDescription"`
TaskId string `json:"taskId"`
Status string `json:"status"`
Solution map[string]any `json:"solution"`
}
func capSolver(ctx context.Context, apiKey string, taskData map[string]any) (*capSolverResponse, error) {
uri := "https://api.capsolver.com/createTask"
res, err := request(ctx, uri, map[string]any{
"clientKey": apiKey,
"task": taskData,
})
if err != nil {
return nil, err
}
if res.ErrorId == 1 {
return nil, errors.New(res.ErrorDescription)
}
uri = "https://api.capsolver.com/getTaskResult"
for {
select {
case <-ctx.Done():
return res, errors.New("tempo esgotado para resolver")
case <-time.After(time.Second):
break
}
res, err = request(ctx, uri, map[string]any{
"clientKey": apiKey,
"taskId": res.TaskId,
})
if err != nil {
return nil, err
}
if res.ErrorId == 1 {
return nil, errors.New(res.ErrorDescription)
}
if res.Status == "ready" {
return res, err
}
}
}
func request(ctx context.Context, uri string, payload interface{}) (*capSolverResponse, error) {
payloadBytes, err := json.Marshal(payload)
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, "POST", uri, bytes.NewReader(payloadBytes))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
responseData, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
capResponse := &capSolverResponse{}
err = json.Unmarshal(responseData, capResponse)
if err != nil {
return nil, err
}
return capResponse, nil
}
func main() {
apikey := "SUA_CHAVE_DE_API"
ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
defer cancel()
res, err := capSolver(ctx, apikey, map[string]any{
"type": "ReCaptchaV2TaskProxyLess",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
if err != nil {
panic(err)
}
fmt.Println(res.Solution["gRecaptchaResponse"])
}
Usando ferramentas como Playwright e CapSolver, você pode automatizar a resolução de CAPTCHAs, tornando tarefas de raspagem de web e automação mais eficientes. Seja lidando com captcha ou reCAPTCHA, os métodos descritos aqui fornecem uma solução robusta para superar esses desafios.
A legalidade de resolver CAPTCHAs depende dos Termos de Serviço do site, leis locais aplicáveis e como a automação é usada. O CapSolver é uma ferramenta neutra projetada para casos de uso legítimos, como testes, automação de QA, acessibilidade e coleta de dados autorizada. Antes de implantar qualquer solução de resolução de CAPTCHA, você deve garantir que tenha permissão do site-alvo e que seu uso esteja em conformidade com as regulamentações relevantes.
O CapSolver suporta uma ampla gama de sistemas de CAPTCHA modernos, incluindo, mas não se limitando a:
O suporte está disponível por meio de extensões de navegador (para Playwright, Puppeteer, etc.) e soluções baseadas em API para automação de backend.
Use a extensão CapSolver quando:
Use a API CapSolver quando:
Em muitas configurações de produção, as equipes combinam ambos os métodos conforme o cenário.
O CapSolver é otimizado para altas taxas de sucesso e baixa latência. Na maioria dos casos, os desafios reCAPTCHA v2 são resolvidos em poucos segundos, dependendo das condições da rede e da complexidade da tarefa. Para automação em larga escala, o CapSolver também suporta concorrência e throughput estável, tornando-o adequado para fluxos de trabalho de raspagem e testes de nível corporativo.
Enfrentando "Chave de Site Inválida do reCAPTCHA" ou "token do reCAPTCHA inválido"? Descubra causas comuns, soluções passo a passo e dicas de solução de problemas para resolver problemas de verificação do reCAPTCHA. Aprenda como corrigir o erro de verificação do reCAPTCHA, por favor tente novamente.

Aprenda como corrigir problemas comuns do reCAPTCHA na raspagem da web. Descubra soluções práticas para o reCAPTCHA v2 e v3 para manter fluxos de coleta de dados sem interrupções.
