reCAPTCHA v2 企业版完整解决方案指南

# pip install requests
import requests
import time

# 配置
api_key = "YOUR_API_KEY"  # 替换为您的CapSolver API密钥
site_key = ""  # 替换为目标站点的站点密钥
site_url = ""  # 替换为目标站点的页面URL

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

    # 创建任务
    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"创建任务失败：{response.text}")
        return

    print(f"任务创建成功。任务ID：{task_id}。正在检索结果...")

    # 轮询任务结果
    while True:
        time.sleep(3)  # 请求之间的延迟
        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"解决失败！响应：{result_response.text}")
            return

token = capsolver()
if token:
    print(f"CAPTCHA解决成功。令牌：{token}")

package main

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

// capSolverResponse 代表 CapSolver API 的响应结构
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 处理与 CapSolver API 的通信以解决 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 处理对 CapSolver API 的 HTTP POST 请求
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, "POST", url, 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
    }

    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": "", // 替换为目标网站 URL
        "websiteKey": "", // 替换为目标站点密钥
    })

    if err != nil {
        panic(err)
    }

    fmt.Printf("CAPTCHA 解决成功。令牌：%v\n", result.Solution["gRecaptchaResponse"])
}