Guía completa para resolver reCAPTCHA v2 Enterprise

# pip install requests
import requests
import time

# Configuración
api_key = "YOUR_API_KEY"  # Reemplace con su clave API de CapSolver
site_key = ""  # Reemplace con la clave del sitio del sitio objetivo
site_url = ""  # Reemplace con la URL de la página del sitio objetivo

def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'ReCaptchaV2EnterpriseTaskProxyLess',
            "websiteKey": site_key,
            "websiteURL": site_url
        }
    }

    # Cree la tarea
    response = requests.post("https://api.capsolver.com/createTask", json=payload)
    response_data = response.json()
    task_id = response_data.get("taskId")

    if not task_id:
        print(f"Error al crear la tarea: {response.text}")
        return

    print(f"Tarea creada correctamente. ID de la tarea: {task_id}. Recuperando resultado...")

    # Sondee el resultado de la tarea
    while True:
        time.sleep(3)  # Retraso entre solicitudes
        result_payload = {"clientKey": api_key, "taskId": task_id}
        result_response = requests.post("https://api.capsolver.com/getTaskResult", json=result_payload)
        result_data = result_response.json()
        status = result_data.get("status")

        if status == "ready":
            return result_data.get("solution", {}).get('gRecaptchaResponse')
        elif status == "failed" or result_data.get("errorId"):
            print(f"¡La solución falló! Respuesta: {result_response.text}")
            return

token = capsolver()
if token:
    print(f"CAPTCHA resuelto correctamente. Token: {token}")

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "errors"

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

// capSolverResponse representa la estructura de respuesta de la API de CapSolver
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"`
}

// capSolver maneja la comunicación con la API de CapSolver para resolver un CAPTCHA
func capSolver(ctx context.Context, apiKey string, taskData map[string]any) (*capSolverResponse, error) {
	createTaskURL := "https://api.capsolver.com/createTask"
	response, err := request(ctx, createTaskURL, map[string]any{
		"clientKey": apiKey,
		"task":      taskData,
	})

	if err != nil {
		return nil, err
	}
	if response.ErrorId != 0 {
		return nil, errors.New(response.ErrorDescription)
	}

	resultURL := "https://api.capsolver.com/getTaskResult"
	for {
		select {
		case <-ctx.Done():
			return response, errors.New("solve timeout")
		case <-time.After(time.Second):
			result, err := request(ctx, resultURL, map[string]any{
				"clientKey": apiKey,
				"taskId":    response.TaskId,
			})

			if err != nil {
				return nil, err
			}
			if result.ErrorId != 0 {
				return nil, errors.New(result.ErrorDescription)
			}
			if result.Status == "ready" {
				return result, nil
			}
		}
	}
}

// request maneja las solicitudes HTTP POST a la API de CapSolver
func request(ctx context.Context, url string, payload interface{}) (*capSolverResponse, error) {
	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(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()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var response capSolverResponse
	err = json.Unmarshal(body, &response)
	if err != nil {
		return nil, err
	}

	return &response, nil
}

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

type capSolverResponse struct {
	Solution map[string]any `json:"solution"`
}

func capSolver(ctx context.Context, apiKey string, task map[string]any) (*capSolverResponse, error) {
	url := "https://api.capsolver.com/createTask"

	payloadBytes, err := json.Marshal(task)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Token "+apiKey)

	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
	}

	var capResponse capSolverResponse
	if err := json.Unmarshal(responseData, &capResponse); err != nil {
		return nil, err
	}

	return &capResponse, nil
}

func main() {
	apiKey := "YOUR_API_KEY"
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
	defer cancel()

	result, err := capSolver(ctx, apiKey, map[string]any{
		"type":       "ReCaptchaV2EnterpriseTaskProxyLess",
		"websiteURL": "", // Reemplaza con la URL del sitio web objetivo
		"websiteKey": "", // Reemplaza con la clave del sitio objetivo
	})

	if err != nil {
		panic(err)
	}

	fmt.Printf("CAPTCHA resuelto exitosamente. Token: %v\n", result.Solution["gRecaptchaResponse"])
}