Como resolver reCAPTCHA usando Python e GO
Adélia Cruz
Neural Network Developer
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
# 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
# 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
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
{
"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
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
{
"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
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
# 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
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
# 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
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()
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"])}
## 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.Ver mais
reCAPTCHAApr 16, 2026
reCAPTCHA Chave de Site Inválida ou Token Inválido? Causas & Guia de Solução
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.
reCAPTCHAFeb 12, 2026
Como corrigir problemas comuns de reCAPTCHA em raspagem de web
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.
