Como resolver reCAPTCHA usando Python e Go

Como resolver reCAPTCHA usando Python e GO

Adélia Cruz

Neural Network Developer

24-Nov-2025

reCAPTCHA, desenvolvido pelo Google, é uma medida de segurança amplamente utilizada por sites para proteger contra robôs automatizados. Ele apresenta aos usuários desafios para verificar sua identidade humana. Neste artigo, exploraremos como resolver desafios de reCAPTCHA de forma programática usando Python e Go. Cobriremos tanto o reCAPTCHA v2 quanto o v3, fornecendo a você o conhecimento e as ferramentas para superar essas medidas de segurança em seus projetos de raspagem de web.

O que é reCAPTCHA?

O reCAPTCHA oferece proteção robusta para sites, efetivamente impedindo atividades fraudulentas e abuso, enquanto mantém a conveniência do usuário. Potencializado por um motor de avaliação de risco inteligente e desafios adaptativos, ele efetivamente desvia softwares maliciosos e garante acesso suave para usuários legítimos. Com uma trajetória de mais de uma década, o reCAPTCHA defende ativamente a integridade dos dados de inúmeros sites. Sua abordagem sem esforço identifica e bloqueia eficientemente bots e ataques automatizados, permitindo que usuários reais naveguem sem interrupções. Utilizando aprendizado de máquina contínuo, os algoritmos adaptativos do reCAPTCHA analisam as interações dos usuários e comportamentos de bots, superando as limitações dos métodos tradicionais de detecção de bots baseados em desafios.

Existem várias versões do reCAPTCHA:

O reCAPTCHA, desenvolvido pelo Google, possui várias versões, cada uma projetada para diferenciar humanos de bots de formas variadas:

reCAPTCHA v1: A versão inicial exigia que os usuários decifrassem texto distorcido e o digitassem em uma caixa de texto.
reCAPTCHA v2: Esta versão introduz um checkbox para os usuários confirmarem sua identidade humana. Às vezes, também pode solicitar que os usuários selecionem imagens específicas de uma grade.
reCAPTCHA v3: Ao contrário das versões anteriores, esta versão opera em segundo plano, analisando o comportamento do usuário para atribuir uma pontuação indicando a probabilidade de atividade humana ou de bot. Oferece uma experiência sem interrupções, não exigindo interação direta do usuário.

Neste artigo, nosso foco será em resolver o reCAPTCHA V2 e V3. Essas versões geralmente exibem um checkbox com o aviso "Não sou um robô" ou podem aparecer como um selo invisível, visando distinguir usuários reais de bots. Veja como isso funciona na prática:

O Melhor Solver de reCAPTCHA: Capsolver

CapSolver destaca-se como um dos melhores solvers de reCAPTCHA disponíveis no mercado. Oferecendo uma combinação de acessibilidade, velocidade e confiabilidade, o CapSolver utiliza algoritmos de resolução de Captcha com inteligência artificial, resultando em velocidades de resolução mais rápidas e custos reduzidos. Esta solução excepcional garante uma excelente experiência para desenvolvedores ao lidar com desafios de reCAPTCHA.

Por que escolher o CapSolver?

Acessível e Rápido:
O CapSolver oferece preços competitivos, tornando-se uma das opções mais econômicas para resolver reCAPTCHAs. Com seus algoritmos com inteligência artificial, ele alcança velocidades de resolução mais rápidas, economizando tempo valioso.

Alta Confiabilidade:
O CapSolver possui a velocidade de atualização mais rápida entre fornecedores similares, garantindo acesso às tecnologias mais atualizadas e precisas de resolução de captchas. Esta confiabilidade assegura uma experiência de resolução suave e sem interrupções.

Solução sem Risco:
Com o CapSolver, você paga apenas pelos captchas resolvidos com sucesso. Seu processo rigoroso de revisão de cooperação assegura que atividades ilegais sejam identificadas e banidas rapidamente, proporcionando uma plataforma segura e confiável para resolver reCAPTCHAs.

Automação com Inteligência Artificial:
O CapSolver utiliza a potência da inteligência artificial para oferecer resolução totalmente automatizada de captchas. Isso elimina a necessidade de intervenção manual, simplificando o processo de resolução e aumentando a eficiência.

Compatibilidade com Serviços Populares:
O CapSolver funciona de forma suave com as APIs de serviços populares de reconhecimento manual de captchas, garantindo compatibilidade com várias plataformas e sistemas. Esta flexibilidade permite integração fácil em seus fluxos de trabalho existentes.

Soluções Diversas:
Além de seu serviço de API, o CapSolver também oferece uma extensão do Chrome, ampliando suas capacidades e proporcionando mais opções para resolver reCAPTCHAs. Esta versatilidade atende diferentes preferências e necessidades dos usuários.

Confiança de uma Amplas Plataformas:
Com mais de 1000 plataformas integrando a API do CapSolver, ele ganhou a confiança e a confiança de muitas empresas e desenvolvedores. Esta ampla adoção atesta a confiabilidade e a eficácia da solução CapSolver.

Resgate seu código de bônus do CapSolver

Não perca a oportunidade de otimizar ainda mais suas operações! Use o código de bônus CAPN ao recarregar sua conta do CapSolver e receba um bônus adicional de 5% em cada recarga, sem limites. Acesse o CapSolver para resgatar seu bônus agora!

Como Resolver reCAPTCHA v3 - Guia da API

ReCaptchaV3Task

ReCaptchaV3Task é um tipo de tarefa que requer seus próprios proxies para funcionar. É ideal para aqueles que possuem um conjunto de proxies confiáveis disponíveis. O uso de proxies pessoais permite maior controle e personalização no processo de resolução.

python Copy

# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'

import capsolver
# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "ReCaptchaV3Task",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    "proxy":"ip:porta:user:senha", ...
})

ReCaptchaV3TaskProxyLess

Se você não tiver acesso a proxies ou preferir não usá-los, ReCaptchaV3TaskProxyLess é a escolha perfeita. Ele utiliza o proxy integrado ao servidor, tornando o processo mais simplificado e amigável ao usuário.

python Copy

# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'

import capsolver

# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "ReCaptchaV3TaskProxyLess",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    ...
})

Passo 1: Criando uma Tarefa

Para iniciar o processo, você precisa criar uma tarefa de reconhecimento usando o método createTask.

Aqui está um exemplo de solicitação:

json Copy

POST https://api.capsolver.com/createTask

{
  "clientKey":"suaapiKey",
  "task": {
    "type":"ReCaptchaV3Task",
    "websiteURL":"https://antcpt.com/score_detector",
    "websiteKey":"6LcR_okUAAAAAPYrPe-HK_0RULO1aZM15ENyM-Mf",
    "pageAction": "homepage",
    "proxy":"seuproxy"
  }
}

Após a submissão bem-sucedida da tarefa, você receberá um ID da Tarefa na resposta:

json Copy

{
  "errorId": 0,
  "errorCode": "",
  "errorDescription": "",
  "taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}

Passo 2: Obtendo Resultados

Com o ID da Tarefa, você pode usá-lo para obter a solução. Submeta o ID da Tarefa com o método getTaskResult. Os resultados devem estar prontos em um intervalo de 1s a 10s.

Aqui está um exemplo de solicitação:

json Copy

POST https://api.capsolver.com/getTaskResult
Host: api.capsolver.com
Content-Type: application/json

{
  "clientKey":"CHAVE_API_SUA",
  "taskId": "ID DA CREATETASK" //ID criado pelo método createTask
}

A resposta incluirá o token de solução:

json Copy

{
  "errorId": 0,
  "errorCode": null,
  "errorDescription": null,
  "solution": {
    "userAgent": "xxx",
    "expireTime": 1671615324290,
    "gRecaptchaResponse": "3AHJ....."
  },
  "status": "ready"
}

Na resposta, 'solution' contém 'userAgent', o tempo de expiração do token 'expireTime' e o token de solução 'gRecaptchaResponse'. Após o captcha ser resolvido, você pode verificar o token de captcha enviando o token para o site, exemplo:

json Copy

var request = require('request');

var options = {
  method: 'POST',
  url: 'https://antcpt.com/score_detector/verify.php',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ 'g-recaptcha-response': 'aqui o token do capsolver' }),
};

request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

Mais sobre Como Resolver reCAPTCHA v2, você pode consultar esta Documentação

Como Resolver reCAPTCHA Usando Python e GO

Código de exemplo para reCAPTCHA v2

python Copy

# pip install requests
import requests
import time

# TODO: defina suas configurações
api_key = "CHAVE_API_SUA"  # sua chave de API do capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"  # chave do site do seu site alvo
site_url = "https://www.google.com/recaptcha/api2/demo"  # URL da página do seu site alvo


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)  # atraso
        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)

go Copy

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

Código de exemplo para reCAPTCHA v3

python Copy

# pip install requests
import requests
import time

# TODO: defina suas configurações
api_key = "CHAVE_API_SUA"  # sua chave de API do capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-"  # chave do site do seu site alvo
site_url = "https://www.google.com"  # URL da página do seu site alvo


def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'ReCaptchaV3TaskProxyLess',
            "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)  # atraso
        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)

go Copy

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 := "CHAVE_API_SUA"
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
	defer cancel()

	res, err := capSolver(ctx, apikey, map[string]any{
		"type":       "ReCaptchaV3TaskProxyLess",
		"websiteURL": "https://www.google.com/recaptcha/api2/demo",
		"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Solution["gRecaptchaResponse"])
}

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

Copy

res, err := capSolver(ctx, apikey, map[string]any{
	"type":       "ReCaptchaV3TaskProxyLess",
	"websiteURL": "https://www.google.com",
	"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
})
if err != nil {
	panic(err)
}
fmt.Println(res.Solution["gRecaptchaResponse"])

}

Copy

  
## Conclusão
Resolver desafios reCAPTCHA de forma programática usando Python e Go, junto com a poderosa solução [CapSolver](https://dashboard.capsolver.com/dashboard/overview/?utm_source=blog&utm_medium=article&utm_campaign=price-intelligence-captcha), oferece uma abordagem eficaz para raspagem de web e tarefas de automação. Ao entender as intricadas reCAPTCHA v2 e v3 e aproveitar as capacidades do CapSolver, os desenvolvedores podem superar essas medidas de segurança de forma eficiente e confiável. Seguindo os guias completos e exemplos de código fornecidos, você pode integrar com sucesso o Capsolver em suas aplicações Python e Go para resolver desafios reCAPTCHA de forma transparente.

# **Perguntas Frequentes**

### **1. O que este artigo se concentra?**

Explica como resolver reCAPTCHA v2 e v3 de forma programática usando Python e Go, incluindo fluxos completos de API e exemplos de código.

### **2. Para quem é este artigo?**

Desenvolvedores trabalhando em raspagem de web, automação, ferramentas de SEO, sistemas de monitoramento ou qualquer fluxo de trabalho que encontre desafios reCAPTCHA.

### **3. Quais versões de reCAPTCHA são compatíveis?**

reCAPTCHA v2 (checkbox e invisível) e reCAPTCHA v3 (baseado em pontuação).

### **4. O que é necessário para começar?**

* Sitekey do site alvo
* URL da página
* Chave de API do CapSolver
* Opcional: proxy (para tipos de tarefa não proxyless)

### **5. Posso usar os exemplos de código diretamente?**

Sim. Substitua a chave de API, sitekey e URL de destino, e o código funcionará como fornecido.

### **6. Quanto tempo normalmente leva para resolver?**

Geralmente entre 1–10 segundos, dependendo da dificuldade do captcha e do ambiente.

### **7. Como verificar se o token retornado funciona?**

Envie o `gRecaptchaResponse` para o ponto de verificação do site (exemplos fornecidos no artigo).

### **8. O ProxyLess é compatível?**

Sim, ambos os tipos de tarefa reCAPTCHA v2 e v3 têm versões ProxyLess, ideais para usuários sem proxies.

### **9. Ele garante uma pontuação alta no reCAPTCHA v3?**

Oferece simulação de ambiente de alta qualidade, mas as pontuações finais dependem da avaliação de risco da Google.

### **10. Pode ser usado em projetos em larga escala ou comerciais?**

Sim. A API é adequada para raspagem de alta volume, pipelines de automação e sistemas escaláveis.

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

Resolver reCAPTCHA com JavaScript: Um Tutorial Completo

Enquanto o reCAPTCHA protege efetivamente o conteúdo da web, às vezes pode dificultar atividades legítimas, como pesquisa, análise de dados ou outras tarefas de automação orientadas por conformidade que envolvem interação com serviços da web.

reCAPTCHA