Resolva reCAPTCHA Enterprise com Go
Instale solvethree.com/sdk e chame Solve com o hostname de destino, a ação e o proxy. O SDK cria a tarefa uma única vez e consulta o resultado periodicamente. Depois, seu aplicativo envia o token ao destino.
Nesta página
Instale e configure o SDK
Use Go 1.22+. No seu módulo Go, execute:
go get solvethree.com/sdk@v0.1.0- Defina
SOLVETHREE_API_KEYcom a chave de API do seu espaço de trabalho eSOLVETHREE_PROXYcom a URL do seu proxy HTTP(S). Mantenha ambos na configuração do servidor. - Crie um perfil ativo para o hostname de destino no seu espaço de trabalho. Consulte a configuração do perfil de site.
- Substitua
accounts.example.comeloginpelo hostname e pela ação usados pelo destino.Siterecebe um hostname, sem esquema ou caminho.
Resolva uma tarefa
Salve como main.go e execute go run ..
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.
}O contexto limita a espera local a 180 segundos. Solve retorna um TaskResult pronto ou um erro; você não precisa adicionar outro loop de consultas periódicas ao redor dele. Esta requisição usa o modo padrão Enterprise v3. Para v3 comum, defina RecaptchaType: "v3". Deixe Type e URL sem definição para reCAPTCHA.
Envie o token ao destino
Envie result.Solution.Token no campo de CAPTCHA do aplicativo. O valor exibido de result.ID identifica a tarefa; ele não é o token.
Use result.Solution.UserAgent como User-Agent e result.Solution.SecChUA como sec-ch-ua. Encaminhe a requisição ao destino pelo proxy bem-sucedido da resolução, selecionado com solvethree.SuccessfulProxy(input, result).
Inclua os outros campos do formulário, os cookies e o valor de CSRF do aplicativo e, em seguida, verifique a resposta. O SDK retorna uma solução; ele não envia a requisição ao aplicativo por você.
Guarde os IDs se a espera for interrompida
Cancelar o contexto interrompe a espera local, não o trabalho remoto. *solvethree.Error expõe RequestID e TaskID. Consulte uma tarefa conhecida com GetTask; se houver incerteza sobre a criação, reenvie exatamente os parâmetros originais com o mesmo RequestID.
Para permitir a recuperação após reinícios do processo, atribua e salve RequestID com os parâmetros da tarefa antes da criação. Um *TaskFailedError é terminal: inspecione seu ErrorCode e consulte a tarefa para obter o texto do erro. Corrija a causa antes de iniciar outra resolução.
Alternativa: chame a API REST com a biblioteca padrão
Se você preferir controlar as chamadas HTTP, esta versão usa net/http diretamente. Escolha esta versão ou o exemplo com SDK acima; executar ambos cria duas tarefas. As structs de resposta aqui pertencem a este exemplo independente, por isso seus nomes de campos diferem dos tipos do SDK.
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)
}Fontes e referência da API
Execute sua primeira tarefa.
Comece com $5 em créditos no espaço de trabalho.