פתרון reCAPTCHA Enterprise באמצעות Go

go get solvethree.com/sdk@v0.1.0

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"
    solvethree "solvethree.com/sdk"
)

func main() {
    client, err := solvethree.NewClient(os.Getenv("SOLVETHREE_API_KEY"), nil)
    if err != nil { log.Fatal(err) }
    ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
    defer cancel()
    input := solvethree.TaskRequest{Site: "accounts.example.com", Action: "login", Proxy: os.Getenv("SOLVETHREE_PROXY")}
    result, err := client.Solve(ctx, input, solvethree.SolveOptions{})
    if err != nil { log.Fatal(err) }
    fmt.Println("Ready task:", result.ID)
    // Submit result.Solution.Token with its browser identity and original proxy.
}

package main

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

type Task struct {
    ID string `json:"id"`
    Status string `json:"status"`
    ErrorCode string `json:"errorCode"`
    Error string `json:"error"`
    Solution struct {
        Token string `json:"token"`
        UserAgent string `json:"userAgent"`
        SecChUa string `json:"secChUa"`
    } `json:"solution"`
}

func main() {
    key, proxy := os.Getenv("SOLVETHREE_API_KEY"), os.Getenv("SOLVETHREE_PROXY")
    if key == "" || proxy == "" { panic("Set SOLVETHREE_API_KEY and SOLVETHREE_PROXY") }
    ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
    defer cancel()
    client := &http.Client{Timeout: 30*time.Second}
    api := func(method, path string, body []byte) (Task, error) {
        var task Task
        req, err := http.NewRequestWithContext(ctx, method, "https://api.solvethree.com/v1"+path, bytes.NewReader(body))
        if err != nil { return task, err }
        req.Header.Set("Authorization", "Bearer "+key)
        req.Header.Set("Content-Type", "application/json")
        response, err := client.Do(req)
        if err != nil { return task, err }
        defer response.Body.Close()
        if response.StatusCode < 200 || response.StatusCode >= 300 { return task, fmt.Errorf("API HTTP %d", response.StatusCode) }
        err = json.NewDecoder(response.Body).Decode(&task)
        return task, err
    }
    requestID := fmt.Sprintf("go-%d", time.Now().UnixNano())
    body, err := json.Marshal(map[string]string{
        "site":"accounts.example.com", "action":"login", "proxy":proxy, "requestId":requestID,
    })
    if err != nil { panic(err) }
    // Persist requestID and body before creation if this must survive a restart.
    task, err := api(http.MethodPost, "/tasks?waitMs=0", body)
    if err != nil { panic(fmt.Errorf("request %s: %w", requestID, err)) }
    for task.Status == "pending" || task.Status == "solving" {
        task, err = api(http.MethodGet, "/tasks/"+url.PathEscape(task.ID)+"?waitMs=15000", nil)
        if err != nil { panic(err) }
        if task.Status == "pending" || task.Status == "solving" {
            select { case <-ctx.Done(): panic(ctx.Err()); case <-time.After(time.Second): }
        }
    }
    if task.Status != "ready" { panic("Task failed: "+task.ErrorCode+": "+task.Error) }
    solution := task.Solution
    _ = solution // Apply token and returned browser identity using the same proxy.
    fmt.Println("Ready task:", task.ID)
}