Use a Ticketmaster TMPT cookie with Go

Create a TaskRequest with Type set to TicketmasterTmptTask, a target URL, an Action, and a proxy input.

• For an event, use Event and the exact event URL you intend to request.
• For sign-in, use Login and the sign-in entry URL.

Don't send Site, RecaptchaType, or a session field. TMPT returns a raw cookie value, not a reCAPTCHA token or a Kasada headers object.

Use Go 1.22 or newer and the official module solvethree.com/sdk at version v0.1.0. Installation details are in the Go integration documentation. Set SOLVETHREE_API_KEY to your workspace key and SOLVETHREE_PROXY to your proxy URL. Keep the API key on the server.

The example uses Login. For an event, change Action to Event and replace URL with the exact event URL before solving. For login, confirm that URL is the intended sign-in entry URL. The later GET uses that same 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 selects the proxy to use for submission. The example configures that proxy on a cloned http.Transport, copies Solution.UserAgent and Solution.SecChUA into the request headers, and attaches Solution.Token as the tmpt cookie. Don't replace those values with an unrelated browser identity or switch proxies between solving and submission.

The example attaches the cookie directly with request.AddCookie; it doesn't create a cookie jar. If your application uses a jar, replace that attachment step with the following sequence.

1. 1.

   Attach a jar to the target client

   Create a jar with the standard-library net/http/cookiejar package and assign it to the target HTTP client's Jar field.

2. 2.

   Store the raw token for the target URL

   Parse input.URL and pass that URL to the jar's SetCookies method with an http.Cookie named tmpt whose Value is result.Solution.Token. Don't include a tmpt= prefix in the value or store the cookie against the solvethree API URL.

3. 3.

   Send the GET with the configured client

   Keep the successful proxy on the transport and the returned browser identity on the request. The jar handles cookie attachment; it doesn't configure the proxy or those headers.

The two printed values answer different questions: the ready task ID identifies the generated solution; the application HTTP status comes from the target request. Inspect the response body as well as the status. A ready task doesn't prove login, event access, or queue admission.

Redirect following is disabled in the example, so you can inspect the initial response and its Location header rather than seeing only the final destination.

The task is ready, but the target rejects the request.

Inspect the outgoing cookie, target URL, proxy, User-Agent, and sec-ch-ua.

Try this: Send the raw Solution.Token as tmpt to the intended URL, using SuccessfulProxy and the identity returned with that solution.

Solving fails before the target GET.

Handle the Solve error. For a terminal failed task, inspect errorCode and error.

Try this: Stop polling that task and correct the reported problem before retrying. Don't assume every failure means insufficient credit.