reCAPTCHA, desarrollada por Google, es una medida de seguridad ampliamente utilizada implementada por los sitios web para protegerse contra bots automatizados. Presenta a los usuarios desafíos para verificar su identidad humana. En este artículo, exploraremos cómo resolver desafíos de reCAPTCHA de manera programática utilizando Python y Go. Cubriremos tanto reCAPTCHA v2 como v3, proporcionándote el conocimiento y las herramientas necesarias para superar estas medidas de seguridad en tus proyectos de scraping web.

¿Qué es reCAPTCHA?

reCAPTCHA ofrece una protección sólida para los sitios web, evitando eficazmente actividades fraudulentas y abusos, mientras mantiene la comodidad del usuario. Impulsada por un motor de evaluación de riesgos inteligente y desafíos adaptativos, detiene eficazmente el software malicioso y garantiza un acceso fluido para usuarios legítimos. Con una trayectoria de más de una década, reCAPTCHA defiende activamente la integridad de los datos para incontables sitios web. Su enfoque sin interrupciones identifica y bloquea eficazmente bots y ataques automatizados, permitiendo a los usuarios reales navegar sin interrupciones. Aprovechando el aprendizaje continuo de máquinas, los algoritmos adaptativos de reCAPTCHA analizan las interacciones del usuario y los comportamientos de los bots, superando las limitaciones de los métodos tradicionales de detección de bots basados en desafíos.

Existen varias versiones de reCAPTCHA:

reCAPTCHA, desarrollada por Google, cuenta con varias versiones, cada una diseñada para diferenciar entre humanos y bots de maneras distintas:

• reCAPTCHA v1: La primera versión requería a los usuarios que decodificaran texto distorsionado e ingresaran el resultado en una caja de texto.
• reCAPTCHA v2: Esta versión introduce una casilla de verificación para que los usuarios confirmen su identidad humana. A veces, también puede solicitar a los usuarios que seleccionen imágenes específicas de una cuadrícula.
• reCAPTCHA v3: A diferencia de sus predecesores, esta versión opera en segundo plano, analizando el comportamiento del usuario para asignar una puntuación que indica la probabilidad de actividad humana o de bot. Ofrece una experiencia sin interrupciones, sin requerir ninguna interacción directa del usuario.

En este artículo, nos enfocaremos en resolver desafíos de reCAPTCHA V2 y V3. Estas versiones suelen mostrar una casilla de verificación con el mensaje "No soy un robot" o pueden aparecer como un sello invisible, con el objetivo de distinguir usuarios reales de bots. Así es como se ve en acción:

"

El mejor solucionador de reCAPTCHA: Capsolver

CapSolver se destaca como uno de los mejores solucionadores de reCAPTCHA disponibles en el mercado. Ofrece una combinación de asequibilidad, velocidad y fiabilidad, utilizando algoritmos de resolución de Captcha impulsados por inteligencia artificial, lo que resulta en velocidades de resolución más rápidas y costos reducidos. Esta solución excepcional garantiza una excelente experiencia para desarrolladores al manejar desafíos de reCAPTCHA.

¿Por qué elegir CapSolver?

Asequible y rápido:
CapSolver ofrece precios competitivos, convirtiéndose en una de las opciones más económicas para resolver reCAPTCHAs. Con sus algoritmos impulsados por inteligencia artificial, logra velocidades de resolución más rápidas, ahorrando tiempo valioso.

Alta fiabilidad:
CapSolver destaca por tener la velocidad de actualización más rápida entre proveedores similares, asegurando que tengas acceso a la tecnología más actualizada y precisa para resolver captchas. Esta fiabilidad garantiza una experiencia de resolución fluida e ininterrumpida.

Solución sin riesgos:
Con CapSolver, solo pagas por captchas resueltos con éxito. Su estricto proceso de revisión de cooperación asegura que cualquier actividad ilegal sea identificada y prohibida rápidamente, proporcionando una plataforma segura y confiable para resolver reCAPTCHAs.

Automatización impulsada por inteligencia artificial:
CapSolver aprovecha el poder de la inteligencia artificial para ofrecer una resolución completa de captchas automatizada. Esto elimina la necesidad de intervención manual, optimizando el proceso de resolución y mejorando la eficiencia.

Compatibilidad con servicios populares:
CapSolver funciona sin problemas con las APIs de servicios populares de reconocimiento de captchas manuales, asegurando compatibilidad con diversas plataformas y sistemas. Esta flexibilidad permite una integración sencilla en tus flujos de trabajo existentes.

Soluciones diversas:
Además de su servicio de API, CapSolver también ofrece una extensión de Chrome, ampliando sus capacidades y proporcionando más opciones para resolver reCAPTCHAs. Esta versatilidad atiende diferentes preferencias y requisitos de los usuarios.

Confianza de una amplia gama de plataformas:
Con más de 1000 plataformas que integran la API de CapSolver, ha ganado la confianza de numerosas empresas y desarrolladores. Esta amplia adopción atestigua la fiabilidad y efectividad de la solución de CapSolver.

Redime tu código de bonificación de CapSolver

No pierdas la oportunidad de optimizar aún más tus operaciones. Usa el código de bonificación CAPN al recargar tu cuenta de CapSolver y recibe un 5% adicional en cada recarga, sin límites. Visita CapSolver para redimir tu bonificación ahora!

Cómo resolver reCAPTCHA v3 - Guía de la API

ReCaptchaV3Task

ReCaptchaV3Task es un tipo de tarea que requiere que uses tus propios proxies para funcionar. Es ideal para quienes tienen un conjunto de proxies confiables disponibles. El uso de proxies personales permite un mayor control y personalización en el proceso de resolución.

# 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:port:user:pass", ...
})

ReCaptchaV3TaskProxyLess

Si no tienes acceso a proxies o prefieres no usarlos, ReCaptchaV3TaskProxyLess es una excelente opción. Utiliza el proxy integrado en el servidor, lo que hace que el proceso sea más fluido y amigable para el usuario.

# 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-",
    "proxy":"ip:port:user:pass", ...
})

Paso 1: Crear una tarea

Para comenzar el proceso, necesitas crear una tarea de reconocimiento usando el método createTask.

Aquí hay un ejemplo de solicitud:

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

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

Una vez que la tarea se haya enviado correctamente, recibirás un ID de tarea en la respuesta:

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

Paso 2: Obtener resultados

Una vez que tengas el ID de tarea, puedes usarlo para recuperar la solución. Envía el ID de tarea con el método getTaskResult. Los resultados deberían estar listos en un intervalo de 1s a 10s.

Aquí hay un ejemplo de solicitud:

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

{
  "clientKey":"TU_CLAVE_DE_API",
  "taskId": "ID DE CREATETASK" //ID creado por el método createTask
}

La respuesta incluirá el token de solución:

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

En la respuesta, 'solution' contiene 'userAgent', el tiempo de expiración del token 'expireTime' y el token de solución 'gRecaptchaResponse'. Después de que el captcha haya sido resuelto, puedes verificar el token de captcha enviando el token al sitio, ejemplo:

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': 'aquí el token de capsolver' }),
};

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

Más información sobre cómo Resolver reCAPTCHA v2, puedes consultar esta Documentación

Cómo resolver reCAPTCHA utilizando Python y GO

Código de muestra para reCAPTCHA v2

# pip install requests
import requests
import time

# TODO: establezca su configuración
api_key = "TU_CLAVE_DE_API"  # tu clave de API de capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"  # clave del sitio de tu sitio objetivo
site_url = "https://www.google.com/recaptcha/api2/demo"  # URL de la página de tu sitio objetivo


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("No se pudo crear la tarea:", res.text)
        return
    print(f"Obtenido taskId: {task_id} / Obteniendo resultado...")

    while True:
        time.sleep(3)  # retraso
        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("¡La resolución falló! respuesta:", 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("tiempo de resolución agotado")
		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 := "TU_CLAVE_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"])
}

Código de muestra para reCAPTCHA v3

# pip install requests
import requests
import time

# TODO: establezca su configuración
api_key = "TU_CLAVE_DE_API"  # tu clave de API de capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-"  # clave del sitio de tu sitio objetivo
site_url = "https://www.google.com"  # URL de la página de tu sitio objetivo


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("No se pudo crear la tarea:", res.text)
        return
    print(f"Obtenido taskId: {task_id} / Obteniendo resultado...")

    while True:
        time.sleep(1)  # retraso
        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("¡La resolución falló! respuesta:", 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("solve timeout")
		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 := "TU_CLAVE_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/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 := "YOUR_API_KEY"
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"])

}

Conclusión

Resolver desafíos de reCAPTCHA de forma programática utilizando Python y Go, junto con la poderosa solución CapSolver, ofrece un enfoque efectivo para tareas de raspado web y automatización. Al comprender las complejidades de reCAPTCHA v2 y v3 y aprovechar las capacidades de CapSolver, los desarrolladores pueden superar estas medidas de seguridad de manera eficiente y confiable. Siguiendo las guías completas y los ejemplos de código proporcionados, puedes integrar correctamente CapSolver en tus aplicaciones de Python y Go para resolver desafíos de reCAPTCHA de forma fluida.

Preguntas frecuentes

1. ¿De qué se trata este artículo?

Explica cómo resolver programáticamente desafíos de reCAPTCHA v2 y v3 usando Python y Go, incluyendo flujos de API completos y ejemplos de código.

2. ¿Para quién es este artículo?

Desarrolladores que trabajan en raspado web, automatización, herramientas de SEO, sistemas de monitoreo o cualquier flujo de trabajo que se encuentre con desafíos de reCAPTCHA.

3. ¿Qué versiones de reCAPTCHA se admiten?

reCAPTCHA v2 (casilla e invisible) y reCAPTCHA v3 (basado en puntuación).

4. ¿Qué necesito para comenzar?

• La clave del sitio de la web objetivo
• La URL de la página
• La clave de API de CapSolver
• Opcional: proxy (para tipos de tarea sin proxy)

5. ¿Puedo usar los ejemplos de código directamente?

Sí. Reemplaza la clave de API, la clave del sitio y la URL objetivo, y el código funcionará como se proporciona.

6. ¿Cuánto tiempo suele tomar resolverlo?

Normalmente entre 1 y 10 segundos, dependiendo de la dificultad del captcha y el entorno.

7. ¿Cómo verifico que el token devuelto funciona?

Envía el gRecaptchaResponse al punto de verificación de la web (ejemplos proporcionados en el artículo).

8. ¿Está admitido ProxyLess?

Sí, ambos tipos de tarea de reCAPTCHA v2 y v3 tienen opciones ProxyLess, ideales para usuarios sin proxies.

9. ¿Garantiza una alta puntuación en reCAPTCHA v3?

Proporciona una simulación de entorno de alta calidad, pero las puntuaciones finales dependen de la evaluación de riesgo de Google.

10. ¿Puede usarse en proyectos a gran escala o comerciales?

Sí. La API es adecuada para raspado de alto volumen, pipelines de automatización y sistemas escalables.