# pip install requests
import requests
import time

# Configuration
api_key = "YOUR_API_KEY"  # Replace with your CapSolver API key
site_key = ""  # Replace with the site key of the target site
site_url = ""  # Replace with the page URL of the target site

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

    # Create the task
    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"Failed to create task: {response.text}")
        return

    print(f"Task created successfully. Task ID: {task_id}. Retrieving result...")

    # Poll for the task result
    while True:
        time.sleep(3)  # Delay between requests
        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"Solve failed! Response: {result_response.text}")
            return

token = capsolver()
if token:
    print(f"CAPTCHA solved successfully. Token: {token}")

package main

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

// capSolverResponse represents the response structure from 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 handles the communication with CapSolver API to solve a 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 handles the HTTP POST requests to CapSolver API
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": "", // Replace with the target website URL
        "websiteKey": "", // Replace with the target site key
    })

    if err != nil {
        panic(err)
    }

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