Utiliser un cookie TMPT Ticketmaster avec Go

Créez un TaskRequest avec Type défini sur TicketmasterTmptTask, une URL cible, une Action et un paramètre de proxy.

• Pour un événement, utilisez Event et l’URL exacte de l’événement que vous comptez demander.
• Pour la connexion, utilisez Login et l’URL d’entrée de connexion.

N’envoyez pas Site, RecaptchaType ni de champ de session. TMPT renvoie une valeur de cookie brute, et non un jeton reCAPTCHA ou un objet d’en-têtes Kasada.

Utilisez Go 1.22 ou une version plus récente et le module officiel solvethree.com/sdk en version v0.1.0. Les détails d’installation figurent dans la documentation d’intégration Go. Définissez SOLVETHREE_API_KEY sur la clé de votre espace de travail et SOLVETHREE_PROXY sur l’URL de votre proxy. Conservez la clé API sur le serveur.

L’exemple utilise Login. Pour un événement, définissez Action sur Event et remplacez URL par l’URL exacte de l’événement avant la résolution. Pour la connexion, vérifiez que URL est bien l’URL d’entrée de connexion voulue. La requête GET ultérieure utilise cette même valeur input.URL.

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: "TicketmasterTmptTask", URL: "https://www.ticketmaster.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)

    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)
    request.AddCookie(&http.Cookie{Name: "tmpt", Value: result.Solution.Token})

    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.

}

SuccessfulProxy sélectionne le proxy à utiliser pour l’envoi. L’exemple configure ce proxy sur un http.Transport cloné, copie Solution.UserAgent et Solution.SecChUA dans les en-têtes de la requête et joint Solution.Token comme cookie tmpt. Ne remplacez pas ces valeurs par une identité de navigateur sans rapport et ne changez pas de proxy entre la résolution et l’envoi.

L’exemple joint directement le cookie avec request.AddCookie ; il ne crée pas de gestionnaire de cookies. Si votre application utilise un tel gestionnaire, remplacez cette étape par la séquence suivante.

1. 1.

   Associer un gestionnaire de cookies au client cible

   Créez un gestionnaire de cookies avec le package net/http/cookiejar de la bibliothèque standard et affectez-le au champ Jar du client HTTP cible.

2. 2.

   Stocker le jeton brut pour l’URL cible

   Analysez input.URL et transmettez cette URL à la méthode SetCookies du gestionnaire avec un http.Cookie nommé tmpt dont la valeur Value est result.Solution.Token. N’incluez pas de préfixe tmpt= dans la valeur et n’associez pas le cookie à l’URL de l’API solvethree.

3. 3.

   Envoyer la requête GET avec le client configuré

   Conservez le proxy ayant réussi dans le transport et l’identité de navigateur renvoyée dans la requête. Le gestionnaire se charge de joindre les cookies ; il ne configure ni le proxy ni ces en-têtes.

Les deux valeurs affichées répondent à des questions différentes : l’ID de la tâche prête identifie la solution générée ; le statut HTTP de l’application provient de la requête vers la cible. Examinez le corps de la réponse ainsi que son statut. Une tâche prête ne prouve ni la connexion, ni l’accès à l’événement, ni l’admission dans la file d’attente.

Le suivi des redirections est désactivé dans l’exemple pour vous permettre d’examiner la réponse initiale et son en-tête Location plutôt que de voir uniquement la destination finale.

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

Examinez le cookie envoyé, l’URL cible, le proxy, User-Agent et sec-ch-ua.

Essayez ceci : Envoyez la valeur brute de Solution.Token en tant que tmpt à l’URL voulue, en utilisant SuccessfulProxy et l’identité renvoyée avec cette solution.

La résolution échoue avant la requête GET vers la cible.

Gérez l’erreur de Solve. Pour une tâche ayant échoué définitivement, examinez errorCode et error.

Essayez ceci : Cessez d’interroger cette tâche et corrigez le problème signalé avant de réessayer. Ne supposez pas que chaque échec signifie un crédit insuffisant.