Resuelve captchas ilimitados con el mejor solucionador de captchas

Introducción

CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart) es un mecanismo de seguridad diseñado para distinguir a los usuarios humanos de los bots automatizados. A menudo presenta desafíos como reconocimiento de imágenes, texto distorsionado o acertijos interactivos que son fáciles para los humanos pero difíciles para los bots. Aunque los CAPTCHAs protegen los sitios web del abuso automatizado, pueden ser un obstáculo significativo para la automatización legítima y las actividades de scraping web.

En este blog, exploraremos cómo resolver CAPTCHAs utilizando Playwright con la extensión de CapSolver. Además, veremos cómo resolver reCAPTCHA utilizando la API de CapSolver con Python y Go.

¿Qué es CAPTCHA?

CAPTCHA es un mecanismo de seguridad utilizado por los sitios web para evitar el acceso automatizado y asegurarse de que el usuario sea humano. Los tipos comunes incluyen:

• Reconocimiento de imágenes: Los usuarios deben seleccionar imágenes que coincidan con una descripción específica.
• Texto distorsionado: Los usuarios escriben texto distorsionado que aparece en la pantalla.
• Desafíos interactivos: Los usuarios completan tareas como arrastrar deslizadores o resolver acertijos.

CapSolver: Tu solución para los desafíos de CAPTCHA

CapSolver es una herramienta poderosa diseñada para resolver automáticamente diversos tipos de CAPTCHAs, incluyendo CAPTCHA y reCAPTCHA. Ofrece extensiones para navegadores y APIs para una integración fluida en tus flujos de automatización web.

Redime tu código de bonificación de CapSolver

¡Aumenta tu presupuesto de automatización de inmediato!
Usa el código de bonificación CAPN al recargar tu cuenta de CapSolver para obtener un 5% adicional en cada recarga — sin límites.
Redímelo ahora en tu Panel de CapSolver
.

Instalación de Playwright y componentes necesarios

Primero, necesitas instalar Playwright. Puedes hacerlo a través de npm:

npm install playwright

Configuración de la extensión de CapSolver

1. Descarga la extensión de CapSolver desde aquí.
2. Descomprímela en el directorio ./CapSolver.Browser.Extension en la raíz de tu proyecto.
3. Ajusta la configuración en ./assets/config.json. Asegúrate de que enabledForcaptcha esté en true y establece captchaMode en token para resolver automáticamente.

Cambio de configuración de ejemplo:

{
  "enabledForcaptcha": true,
  "captchaMode": "token"
}

Configuración de Playwright para resolver CAPTCHA con la extensión de CapSolver

A continuación, se muestra un script de ejemplo que utiliza Playwright para resolver CAPTCHA con la extensión de 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');

  // Localiza la casilla de verificación de CAPTCHA o el marco y actúa en consecuencia
  await page.waitForSelector('selector-for-captcha', { state: 'visible' });
  await page.click('selector-for-captcha');

  // Añade pasos adicionales según tus necesidades
  // ...

  await browser.close();
})();

Resolviendo reCAPTCHA con la API de CapSolver

Para reCAPTCHA, puedes usar la API de CapSolver. A continuación, se muestran ejemplos en Python y Go.

Ejemplo en Python

import requests
import time

api_key = "TU_CLAVE_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("No se pudo crear la tarea:", res.text)
        return
    print(f"Obtenido taskId: {task_id} / Obteniendo 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("¡Fallo al resolver! respuesta:", res.text)
            return

token = capsolver()
print(token)

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

Conclusión

Usando herramientas como Playwright y CapSolver, puedes automatizar la resolución de CAPTCHAs, haciendo que las tareas de scraping web y automatización sean más eficientes. Ya sea que estés lidiando con CAPTCHA o reCAPTCHA, los métodos descritos aquí proporcionan una solución sólida para superar estos desafíos.

Preguntas frecuentes (FAQs)

1. ¿Es legal resolver CAPTCHAs programáticamente usando CapSolver?

La legalidad de resolver CAPTCHAs depende de los Términos de Servicio del sitio web, las leyes locales aplicables y cómo se utilice la automatización. CapSolver es una herramienta neutral diseñada para casos de uso legítimos como pruebas, automatización de QA, accesibilidad y recolección de datos autorizada. Antes de implementar cualquier solución de resolución de CAPTCHA, debes asegurarte de tener permiso del sitio web objetivo y que tu uso cumpla con las regulaciones pertinentes.

2. ¿Qué tipos de CAPTCHAs soporta CapSolver?

CapSolver soporta una amplia gama de sistemas modernos de CAPTCHA, incluyendo pero no limitado a:

• reCAPTCHA de Google v2 y v3
• AWS WAF
• CAPTCHA basado en imágenes
• Cloudflare Turnstile y Cloudflare Challenge
• GeeTest v3/v4

El soporte está disponible tanto a través de extensiones de navegador (para Playwright, Puppeteer, etc.) como de soluciones basadas en API para automatización en el backend.

3. ¿Cuándo debo usar la extensión de Playwright versus la API de CapSolver?

Usa la extensión de CapSolver cuando:

• Estás automatizando interacciones con navegadores reales usando Playwright
• El CAPTCHA aparece como parte de un flujo de usuario complejo
• Quieres un esfuerzo mínimo de integración

Usa la API de CapSolver cuando:

• Estás resolviendo tokens de reCAPTCHA del lado del servidor
• Necesitas integración independiente del lenguaje (Python, Go, Java, etc.)
• Estás ejecutando automatización a gran escala o sin cabeza

En muchos entornos de producción, los equipos combinan ambos enfoques según la situación.

4. ¿Qué tan confiable y rápida es CapSolver para resolver reCAPTCHA?

CapSolver está optimizada para altas tasas de éxito y baja latencia. En la mayoría de los casos, los desafíos de reCAPTCHA v2 se resuelven en pocos segundos, dependiendo de las condiciones de red y la complejidad de la tarea. Para automatización a gran escala, CapSolver también soporta concurrencia y throughput estable, lo que la hace adecuada para flujos de trabajo de scraping y pruebas a nivel empresarial.