Resolva Captchas Ilimitados com o Melhor Solucionador de Captcha

Introdução

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.

O que é CAPTCHA?

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:

• Reconhecimento de imagem: Os usuários são solicitados a selecionar imagens que correspondam a uma descrição específica.
• Texto distorcido: Os usuários digitam texto distorcido exibido na tela.
• Desafios interativos: Os usuários completam tarefas como arrastar sliders ou resolver quebra-cabeças.

CapSolver: Sua Solução para Desafios de CAPTCHA

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
.

Instalando o Playwright e Componentes Necessários

Primeiro, você precisa instalar o Playwright. Você pode fazer isso via npm:

npm install playwright

Configurando a Extensão CapSolver

1. Baixe a extensão Capsolver aqui.
2. Descompacte-a na pasta ./CapSolver.Browser.Extension no diretório raiz do seu projeto.
3. Ajuste as configurações no ./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"
}

Configurando o Playwright para Resolver captcha com a Extensão CapSolver

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();
})();

Resolvendo reCAPTCHA com a API CapSolver

Para reCAPTCHA, você pode usar a API CapSolver. Aqui estão exemplos em Python e Go.

Exemplo em Python

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)

Exemplo em Go

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"])
}

Conclusão

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.

Perguntas Frequentes (FAQs)

1. É legal resolver CAPTCHAs de forma programática usando o CapSolver?

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.

2. Quais tipos de CAPTCHAs o CapSolver suporta?

O CapSolver suporta uma ampla gama de sistemas de CAPTCHA modernos, incluindo, mas não se limitando a:

• reCAPTCHA v2 e v3 do Google
• AWS WAF
• CAPTCHAs baseados em imagem
• Cloudflare Turnstile e Cloudflare Challenge
• GeeTest v3/v4

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.

3. Quando devo usar a extensão Playwright em vez da API CapSolver?

Use a extensão CapSolver quando:

• Você estiver automatizando interações reais com o navegador usando o Playwright
• O CAPTCHA aparecer como parte de um fluxo de usuário complexo
• Você quiser esforço mínimo de integração

Use a API CapSolver quando:

• Você estiver resolvendo tokens reCAPTCHA do lado do servidor
• Você precisar de integração independente da linguagem (Python, Go, Java, etc.)
• Você estiver executando automação em larga escala ou sem cabeça

Em muitas configurações de produção, as equipes combinam ambos os métodos conforme o cenário.

4. Quão confiável e rápida é o CapSolver para resolver reCAPTCHA?

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.