Générer et appliquer des en-têtes Kasada avec Go

Utilisez Go 1.22 ou une version ultérieure et installez le module officiel solvethree.com/[email protected]. La documentation d’intégration Go décrit l’installation.

Kasada en mode autonome prend actuellement en charge les cibles HTTPS sur le nom d’hôte exact www.ticketmaster.com. L’exemple demande sa page d’accueil ; remplacez input.URL par l’URL voulue sur cet hôte pris en charge.

• Définissez SOLVETHREE_API_KEY sur la clé API de votre espace de travail. Conservez-la sur le serveur.
• Définissez SOLVETHREE_PROXY sur une URL de proxy HTTP ou HTTPS sans chemin, chaîne de requête ni fragment. Cet exemple utilise un seul proxy ; ne fournissez pas également ProxyCandidates.
• Conservez Type défini sur KasadaTask. N’ajoutez pas Site, Action, RecaptchaType, ni de champs de session ou d’identité de navigateur personnalisée.

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "net/http"
    "net/url"
    "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{Type: "KasadaTask", URL: "https://www.ticketmaster.com/", 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)

    proxy, ok := solvethree.SuccessfulProxy(input, result)
    if !ok { log.Fatal("No valid successful proxy") }
    proxyURL, err := url.Parse(proxy)
    if err != nil { log.Fatal(err) }
    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxyURL)
    defer transport.CloseIdleConnections()
    targetClient := &http.Client{Transport: transport, Timeout: 30*time.Second,
        CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
    request, err := http.NewRequestWithContext(ctx, "GET", input.URL, nil)
    if err != nil { log.Fatal(err) }

    request.Header.Set("User-Agent", result.Solution.UserAgent)
    request.Header.Set("sec-ch-ua", result.Solution.SecChUA)
    for name, value := range result.Solution.Headers { request.Header.Set(name, value) }

    response, err := targetClient.Do(request)
    if err != nil { log.Fatal(err) }
    defer response.Body.Close()
    fmt.Println("Application HTTP status:", response.StatusCode)
    // Inspect the application response to determine whether submission succeeded.

}

Pour Kasada, appliquez result.Solution.Headers, et non Solution.Token. La boucle copie tous les en-têtes renvoyés. Les affectations précédentes appliquent également les valeurs UserAgent et SecChUA renvoyées ; ne les remplacez pas par des valeurs de votre propre navigateur.

SuccessfulProxy(input, result) identifie le proxy ayant réussi, et http.ProxyURL achemine la requête vers la cible via ce proxy. Utilisez ce résultat plutôt que de choisir un autre proxy au moment de l’envoi. Cela reste important si vous passez ensuite à des proxys candidats pour la tâche.

La requête vers la cible utilise input.URL : la résolution et l’envoi concernent donc la même URL. Le suivi des redirections est désactivé : le client renvoie la réponse de redirection au lieu d’envoyer automatiquement les en-têtes générés à une autre URL.

Une « tâche prête » signifie qu’une solution a été générée, pas que Ticketmaster l’a acceptée. L’exemple affiche le statut HTTP de l’application, mais vous laisse interpréter la réponse. Examinez le corps de la réponse et le résultat attendu par votre application avant d’enregistrer une réussite.

La tâche est prête, mais la cible rejette la requête.

Examinez la requête envoyée : son URL, chaque en-tête renvoyé, User-Agent, sec-ch-ua et le proxy sélectionné par SuccessfulProxy.

Essayez ceci : Corrigez toute incohérence avant de demander une nouvelle résolution. Une solution prête ne garantit pas son acceptation en aval.

Solve renvoie une erreur avant l’exécution de la requête vers la cible.

Distinguez une erreur HTTP de l’API d’un échec définitif de tâche. Une tâche en échec inclut errorCode et error.

Essayez ceci : Utilisez ces détails pour corriger la requête plutôt que de réessayer avec des paramètres invalides inchangés. Si vous remplacez Solve par une interrogation manuelle, cessez d’interroger la tâche lorsqu’elle échoue.

Consultez la gestion des erreurs de l’API pour les échecs survenant pendant la création ou la résolution d’une tâche.