reCAPTCHA Enterprise mit Go lösen
Installieren Sie solvethree.com/sdk und rufen Sie Solve mit Ihrem Zielhostnamen, der Aktion und dem Proxy auf. Das SDK erstellt die Aufgabe einmal und fragt das Ergebnis per Polling ab. Ihre Anwendung übermittelt das Token anschließend an das Ziel.
Auf dieser Seite
SDK installieren und konfigurieren
Verwenden Sie Go 1.22+. Führen Sie in Ihrem Go-Modul Folgendes aus:
go get solvethree.com/sdk@v0.1.0- Setzen Sie
SOLVETHREE_API_KEYauf den API-Schlüssel Ihres Workspaces undSOLVETHREE_PROXYauf Ihre HTTP(S)-Proxy-URL. Speichern Sie beide in der Serverkonfiguration. - Erstellen Sie in Ihrem Workspace ein aktives Profil für den Zielhostnamen. Siehe Websiteprofil einrichten.
- Ersetzen Sie
accounts.example.comundlogindurch den Hostnamen und die Aktion, die Ihr Ziel verwendet.Siteerwartet einen Hostnamen ohne Schema oder Pfad.
Eine Aufgabe lösen
Speichern Sie dies als main.go und führen Sie go run . aus.
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.
}Der Kontext begrenzt die lokale Wartezeit auf 180 Sekunden. Solve gibt ein fertiges TaskResult oder einen Fehler zurück; Sie benötigen keine weitere Polling-Schleife darum. Diese Anfrage verwendet den standardmäßigen Enterprise-v3-Modus. Setzen Sie für reguläres v3 RecaptchaType: "v3". Lassen Sie Type und URL für reCAPTCHA ungesetzt.
Token an Ihr Ziel übermitteln
Senden Sie result.Solution.Token im CAPTCHA-Feld der Anwendung. Die ausgegebene result.ID identifiziert die Aufgabe; sie ist nicht das Token.
Verwenden Sie result.Solution.UserAgent als User-Agent und result.Solution.SecChUA als sec-ch-ua. Leiten Sie die Anfrage an das Ziel über den erfolgreichen Proxy des Lösungsversuchs, den Sie mit solvethree.SuccessfulProxy(input, result) auswählen.
Fügen Sie die übrigen Formularfelder, Cookies und den CSRF-Wert der Anwendung hinzu und prüfen Sie anschließend deren Antwort. Das SDK gibt eine Lösung zurück; es sendet die Anfrage an die Anwendung nicht für Sie.
IDs aufbewahren, falls das Warten unterbrochen wird
Das Abbrechen des Kontexts beendet das lokale Warten, nicht die Verarbeitung auf dem Server. *solvethree.Error stellt RequestID und TaskID bereit. Rufen Sie eine bekannte Aufgabe mit GetTask ab; wenn unklar ist, ob sie erstellt wurde, senden Sie die exakten ursprünglichen Eingaben mit derselben RequestID erneut.
Für eine Wiederherstellung über Prozessneustarts hinweg vergeben und speichern Sie RequestID zusammen mit den Aufgabeneingaben vor der Erstellung. Ein *TaskFailedError ist endgültig: Prüfen Sie seinen ErrorCode und rufen Sie die Aufgabe ab, um ihren Fehlertext zu erhalten. Beheben Sie die Ursache, bevor Sie einen weiteren Lösungsversuch starten.
Alternative: REST mit der Standardbibliothek aufrufen
Wenn Sie die HTTP-Aufrufe lieber selbst steuern, verwendet diese Variante net/http direkt. Wählen Sie entweder diese Variante oder das obige SDK-Beispiel; wenn Sie beide ausführen, werden zwei Aufgaben erstellt. Die Antwortstrukturen hier gehören zu diesem eigenständigen Beispiel. Ihre Feldnamen unterscheiden sich daher von denen der SDK-Typen.
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)
}Quellen und API-Referenz
Führe deinen ersten Task aus.
Starte mit $5 Workspace-Guthaben.