Ticketmaster tmpt
Ticketmaster runs a reCAPTCHA Enterprise check when a page loads and sets the tmpt cookie when it passes. Sign-in and
other protected actions expect a session that has tmpt.
We build the reCAPTCHA reload request. You make every request to Ticketmaster and Google yourself, from one session.
Some pages, such as event pages, answer a new session with 401 and a gate page that runs the same check before it
shows the page. The steps below are for a normal page view. The gate page lists what changes there.
Base URL: https://tmpt.antibotapi.com
Before you start
Section titled “Before you start”- User agent: Chrome 145–155 on Windows, the same string on every request.
- One session: the same proxy, cookie jar and
Accept-Languagefrom the homepage totmpt. - A Chrome-like client: see Match a real browser.
- Get the reCAPTCHA version from us (
GET /config). - Open the page on Ticketmaster.
- Fetch the reCAPTCHA anchor page from Google.
- Get the reload request from us (
POST /tmpt) as soon as the anchor arrives. - Post the reload request to Google and read the token.
- Send the token to Ticketmaster and store
tmpt.
1. Get the version
Section titled “1. Get the version”curl https://tmpt.antibotapi.com/config -H "x-api-key: YOUR_API_KEY"async function getVersion(apiKey) { const res = await fetch('https://tmpt.antibotapi.com/config', { headers: { 'x-api-key': apiKey } }); if (!res.ok) throw new Error(`config: ${res.status} ${await res.text()}`); return (await res.json()).version;}import requests
def get_version(api_key: str) -> str: res = requests.get("https://tmpt.antibotapi.com/config", headers={"x-api-key": api_key}, timeout=30) res.raise_for_status() return res.json()["version"]import ( "encoding/json" "fmt" "io" "net/http")
func GetVersion(apiKey string) (string, error) { req, _ := http.NewRequest("GET", "https://tmpt.antibotapi.com/config", nil) req.Header.Set("x-api-key", apiKey) resp, err := http.DefaultClient.Do(req) if err != nil { return "", err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { body, _ := io.ReadAll(resp.Body) return "", fmt.Errorf("config: %d %s", resp.StatusCode, body) } var config struct { Version string `json:"version"` } err = json.NewDecoder(resp.Body).Decode(&config) return config.Version, err}The response:
{ "success": true, "version": "NhfdZHzre16wrc2m6BxEdu7J" }version is the reCAPTCHA release to fetch the anchor with. It changes when Google ships a release, so read it for each
session. This call is free.
2. Open the page
Section titled “2. Open the page”This guide uses the homepage. For another page, use its URL in place of the homepage’s here and in steps 4 and 6.
- GET
https://www.ticketmaster.com/as a page navigation. - GET
https://www.ticketmaster.com/eps-mgras the page’s script request, withrefererset to the page. - Keep every cookie both responses set. You need
SID,BIDandeps_sidin step 6. - If the page answers
403, Ticketmaster has blocked your proxy. Switch proxy and start again. - If the page answers
401, it is the gate page. Follow The gate page.
3. Fetch the anchor page
Section titled “3. Fetch the anchor page”GET https://www.google.com/recaptcha/enterprise/anchor as the page’s reCAPTCHA iframe would, with these query
parameters in this order:
| Parameter | Value |
|---|---|
ar |
1 |
k |
6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV, Ticketmaster’s site key |
co |
aHR0cHM6Ly93d3cudGlja2V0bWFzdGVyLmNvbTo0NDM., the page’s origin https://www.ticketmaster.com:443 in Base64, with . for the = padding |
hl |
en |
v |
The version from step 1 |
size |
invisible |
anchor-ms |
20000 |
execute-ms |
30000 |
ovv |
CADq00gF |
cb |
A fresh random string for each fetch (see below) |
Put together, with VERSION and CB filled in:
https://www.google.com/recaptcha/enterprise/anchor?ar=1&k=6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV&co=aHR0cHM6Ly93d3cudGlja2V0bWFzdGVyLmNvbTo0NDM.&hl=en&v=VERSION&size=invisible&anchor-ms=20000&execute-ms=30000&ovv=CADq00gF&cb=CBcb is two random numbers written in base 36, the second mixed with the current time:
function makeCb() { return Math.floor(Math.random() * 2147483648).toString(36) + Math.abs(Math.floor(Math.random() * 2147483648) ^ Date.now()).toString(36);}import randomimport time
DIGITS = "0123456789abcdefghijklmnopqrstuvwxyz"
def _int32(n: int) -> int: n &= 0xFFFFFFFF return n - (1 << 32) if n >= (1 << 31) else n
def _base36(n: int) -> str: out = "" while True: n, digit = divmod(n, 36) out = DIGITS[digit] + out if n == 0: return out
def make_cb() -> str: first = random.randrange(2147483648) second = abs(_int32(random.randrange(2147483648) ^ _int32(int(time.time() * 1000)))) return _base36(first) + _base36(second)import ( "math/rand" "strconv" "time")
func MakeCb() string { first := rand.Int63n(2147483648) second := int64(int32(rand.Int63n(2147483648)) ^ int32(time.Now().UnixMilli())) if second < 0 { second = -second } return strconv.FormatInt(first, 36) + strconv.FormatInt(second, 36)}GET /recaptcha/enterprise/anchor?ar=1&k=6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV&co=...&v=VERSION&...&cb=CB HTTP/2host: www.google.comsec-ch-ua: "Google Chrome";v="155", "Chromium";v="155", "Not(A:Brand";v="24"sec-ch-ua-mobile: ?0sec-ch-ua-platform: "Windows"upgrade-insecure-requests: 1user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7x-browser-channel: stablex-browser-year: 2026x-browser-validation: <from your Chrome version>x-browser-copyright: Copyright 2026 Google LLC. All Rights Reserved.sec-fetch-site: cross-sitesec-fetch-mode: navigatesec-fetch-dest: iframesec-fetch-storage-access: nonereferer: https://www.ticketmaster.com/accept-encoding: gzip, deflate, br, zstdaccept-language: en-GB,en-US;q=0.9,en;q=0.8priority: u=0, iChrome adds the x-browser-* headers to requests to Google. Copy them from a capture of the same Chrome version.
4. Get the reload request from us
Section titled “4. Get the reload request from us”Call us as soon as the anchor arrives. There is no need to wait: we time the reload from the anchor page itself.
curl -X POST https://tmpt.antibotapi.com/tmpt \ -H "x-api-key: YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "page_url": "https://www.ticketmaster.com/", "action": "pageView", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36", "cookies": ["LANGUAGE=en-us", "NDMA=200"], "anchor_html": "<the anchor page from step 3>" }'// anchorHtml comes from step 3. Returns the reload request body as bytes.async function getReload(apiKey, pageUrl, action, userAgent, cookies, anchorHtml) { const res = await fetch('https://tmpt.antibotapi.com/tmpt', { method: 'POST', headers: { 'x-api-key': apiKey, 'Content-Type': 'application/json' }, body: JSON.stringify({ page_url: pageUrl, action, user_agent: userAgent, cookies, anchor_html: anchorHtml }), }); if (!res.ok) throw new Error(`tmpt: ${res.status} ${await res.text()}`); return Buffer.from((await res.json()).reload, 'base64'); // binary protobuf}import base64
import requests
def get_reload(api_key: str, page_url: str, action: str, user_agent: str, cookies: list[str], anchor_html: str) -> bytes: """anchor_html comes from step 3. Returns the reload request body as bytes.""" res = requests.post( "https://tmpt.antibotapi.com/tmpt", headers={"x-api-key": api_key}, json={"page_url": page_url, "action": action, "user_agent": user_agent, "cookies": cookies, "anchor_html": anchor_html}, timeout=30, ) res.raise_for_status() return base64.b64decode(res.json()["reload"]) # binary protobufimport ( "bytes" "encoding/base64" "encoding/json" "fmt" "io" "net/http")
// GetReload returns the reload request body as bytes. anchorHTML comes from step 3.func GetReload(apiKey, pageURL, action, userAgent string, cookies []string, anchorHTML string) ([]byte, error) { body, _ := json.Marshal(map[string]any{"page_url": pageURL, "action": action, "user_agent": userAgent, "cookies": cookies, "anchor_html": anchorHTML}) req, _ := http.NewRequest("POST", "https://tmpt.antibotapi.com/tmpt", bytes.NewReader(body)) req.Header.Set("x-api-key", apiKey) req.Header.Set("Content-Type", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { text, _ := io.ReadAll(resp.Body) return nil, fmt.Errorf("tmpt: %d %s", resp.StatusCode, text) } var made struct { Reload string `json:"reload"` } if err := json.NewDecoder(resp.Body).Decode(&made); err != nil { return nil, err } return base64.StdEncoding.DecodeString(made.Reload) // binary protobuf}| Field | What to send |
|---|---|
page_url |
The page you opened in step 2, as the address bar shows it. |
action |
pageView for a normal page, Event for the gate page. It names the endpoint the token goes to in step 6. |
user_agent |
Your session’s User-Agent. |
cookies |
Your www.ticketmaster.com cookies that are not HttpOnly, as name=value strings. Leave out tmpt. An empty array is fine. |
anchor_html |
The anchor page exactly as Google sent it. |
We load page_url ourselves. The first request for a page we have not seen answers 503 while we load it: ask again
every few seconds until it answers 200. We keep a page for 6 hours after the last request for it.
https://www.ticketmaster.com/ is always loaded.
{ "success": true, "reload": "ChhOaGZkWkh6cmUxNndyYzJtNkJ4RWR1N0..." }reload is the request body as Base64. Each 200 is billed.
5. Post the reload request to Google
Section titled “5. Post the reload request to Google”POST the decoded bytes:
POST /recaptcha/enterprise/reload?k=6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV HTTP/2host: www.google.comcontent-length: <length>sec-ch-ua-platform: "Windows"user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36sec-ch-ua: "Google Chrome";v="155", "Chromium";v="155", "Not(A:Brand";v="24"content-type: application/x-protobuffersec-ch-ua-mobile: ?0accept: */*origin: https://www.google.comx-browser-channel: stablex-browser-year: 2026x-browser-validation: <from your Chrome version>x-browser-copyright: Copyright 2026 Google LLC. All Rights Reserved.sec-fetch-site: same-originsec-fetch-mode: corssec-fetch-dest: emptyreferer: <the anchor URL from step 3>accept-encoding: gzip, deflate, br, zstdaccept-language: en-GB,en-US;q=0.9,en;q=0.8priority: u=1, iGoogle answers with a JSON array after a )]}' line. The token is the second element:
)]}'["rresp","03AFcWeA5...",null,null,null,...]// The token from Google's /reload response.function parseToken(text) { if (!text.startsWith(")]}'")) throw new Error('not a reload response'); const [kind, token] = JSON.parse(text.slice(text.indexOf('\n') + 1)); if (kind !== 'rresp' || typeof token !== 'string') throw new Error('no token'); return token;}import json
def parse_token(text: str) -> str: """The token from Google's /reload response.""" if not text.startswith(")]}'"): raise ValueError("not a reload response") reply = json.loads(text.split("\n", 1)[1]) if reply[0] != "rresp" or not isinstance(reply[1], str): raise ValueError("no token") return reply[1]import ( "encoding/json" "errors" "strings")
// ParseToken returns the token from Google's /reload response.func ParseToken(body []byte) (string, error) { text := string(body) if !strings.HasPrefix(text, ")]}'") { return "", errors.New("not a reload response") } var reply []json.RawMessage if err := json.Unmarshal([]byte(text[strings.IndexByte(text, '\n')+1:]), &reply); err != nil { return "", err } var kind, token string if len(reply) < 2 || json.Unmarshal(reply[0], &kind) != nil || kind != "rresp" || json.Unmarshal(reply[1], &token) != nil { return "", errors.New("no token") } return token, nil}6. Send the token to Ticketmaster
Section titled “6. Send the token to Ticketmaster”Post it to the endpoint you named in action, here /epsf/gec/v3/pageView:
POST /epsf/gec/v3/pageView HTTP/2host: www.ticketmaster.comcontent-length: <length>sec-ch-ua-platform: "Windows"sec-ch-ua: "Google Chrome";v="155", "Chromium";v="155", "Not(A:Brand";v="24"sec-ch-ua-mobile: ?0user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36content-type: application/jsonaccept: */*origin: https://www.ticketmaster.comsec-fetch-site: same-originsec-fetch-mode: corssec-fetch-dest: emptyreferer: https://www.ticketmaster.com/accept-encoding: gzip, deflate, br, zstdaccept-language: en-GB,en-US;q=0.9,en;q=0.8cookie: SID=...; BID=...; eps_sid=...; ...priority: u=1, i
{"hostname":"www.ticketmaster.com","key":"6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV","token":"03AFcWeA5..."}The response sets tmpt. Store it with the session’s other cookies and carry on.
Steps 4–6 in code
Section titled “Steps 4–6 in code”These use each language’s standard HTTP client to keep them short. Send steps 5 and 6 through your Chrome-like client
(see Match a real browser), with the headers shown above, in the same session as steps 2 and 3.
They use parseToken from step 5.
const SITE_KEY = '6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV';
// pageUrl is the page from step 2; anchorUrl and anchorHtml come from step 3. cookies are your// non-HttpOnly www.ticketmaster.com cookies as name=value strings; cookieHeader is the whole cookie// header for www.ticketmaster.com (SID, BID, eps_sid and the rest). Returns the tmpt Set-Cookie line.async function getTmpt({ apiKey, userAgent, pageUrl, anchorUrl, anchorHtml, cookies, cookieHeader }) { // 4. Get the reload request as soon as the anchor arrives. const made = await fetch('https://tmpt.antibotapi.com/tmpt', { method: 'POST', headers: { 'x-api-key': apiKey, 'Content-Type': 'application/json' }, body: JSON.stringify({ page_url: pageUrl, action: 'pageView', user_agent: userAgent, cookies, anchor_html: anchorHtml }), }); if (!made.ok) throw new Error(`tmpt: ${made.status} ${await made.text()}`); const reload = Buffer.from((await made.json()).reload, 'base64'); // binary protobuf
// 5. Post the bytes to Google and read the token. const google = await fetch(`https://www.google.com/recaptcha/enterprise/reload?k=${SITE_KEY}`, { method: 'POST', headers: { 'user-agent': userAgent, 'content-type': 'application/x-protobuffer', referer: anchorUrl }, body: reload, }); const token = parseToken(await google.text());
// 6. Hand the token to Ticketmaster. The response sets tmpt. const view = await fetch('https://www.ticketmaster.com/epsf/gec/v3/pageView', { method: 'POST', headers: { 'user-agent': userAgent, 'content-type': 'application/json', referer: pageUrl, cookie: cookieHeader }, body: JSON.stringify({ hostname: 'www.ticketmaster.com', key: SITE_KEY, token }), }); const tmpt = view.headers.getSetCookie().find((cookie) => cookie.startsWith('tmpt=')); if (!tmpt) throw new Error(`pageView ${view.status}: no tmpt`); return tmpt;}import base64import json
import requests
SITE_KEY = "6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV"
def get_tmpt(session, api_key, user_agent, page_url, anchor_url, anchor_html, cookies): """Steps 4-6. session is your Ticketmaster session, holding the cookies from step 2. page_url is the page from step 2; anchor_url and anchor_html come from step 3; cookies are your non-HttpOnly www.ticketmaster.com cookies as name=value strings. Returns tmpt.""" # 4. Get the reload request as soon as the anchor arrives. made = requests.post( "https://tmpt.antibotapi.com/tmpt", headers={"x-api-key": api_key}, json={"page_url": page_url, "action": "pageView", "user_agent": user_agent, "cookies": cookies, "anchor_html": anchor_html}, timeout=30, ) made.raise_for_status() reload = base64.b64decode(made.json()["reload"]) # binary protobuf
# 5. Post the bytes to Google and read the token. google = session.post( f"https://www.google.com/recaptcha/enterprise/reload?k={SITE_KEY}", headers={"user-agent": user_agent, "content-type": "application/x-protobuffer", "referer": anchor_url}, data=reload, ) token = parse_token(google.text)
# 6. Hand the token to Ticketmaster. The response sets tmpt. view = session.post( "https://www.ticketmaster.com/epsf/gec/v3/pageView", headers={"user-agent": user_agent, "content-type": "application/json", "referer": page_url}, data=json.dumps({"hostname": "www.ticketmaster.com", "key": SITE_KEY, "token": token}, separators=(",", ":")), ) tmpt = view.cookies.get("tmpt") if not tmpt: raise RuntimeError(f"pageView {view.status_code}: no tmpt") return tmptimport ( "bytes" "encoding/base64" "encoding/json" "fmt" "io" "net/http")
const siteKey = "6LcvL3UrAAAAAO_9u8Seiuf-I6F_tP_jSS-zndXV"
// GetTmpt does steps 4-6. client is your Ticketmaster session, with a cookie jar holding the// cookies from step 2. pageURL is the page from step 2; anchorURL and anchorHTML come from step 3;// cookies are your non-HttpOnly www.ticketmaster.com cookies as name=value strings.func GetTmpt(client *http.Client, apiKey, userAgent, pageURL, anchorURL, anchorHTML string, cookies []string) (*http.Cookie, error) { // 4. Get the reload request as soon as the anchor arrives. body, _ := json.Marshal(map[string]any{"page_url": pageURL, "action": "pageView", "user_agent": userAgent, "cookies": cookies, "anchor_html": anchorHTML}) req, _ := http.NewRequest("POST", "https://tmpt.antibotapi.com/tmpt", bytes.NewReader(body)) req.Header.Set("x-api-key", apiKey) req.Header.Set("Content-Type", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } var made struct { Reload string `json:"reload"` } err = json.NewDecoder(resp.Body).Decode(&made) resp.Body.Close() if resp.StatusCode != http.StatusOK || err != nil { return nil, fmt.Errorf("tmpt: %d %v", resp.StatusCode, err) } reload, err := base64.StdEncoding.DecodeString(made.Reload) // binary protobuf if err != nil { return nil, err }
// 5. Post the bytes to Google and read the token. req, _ = http.NewRequest("POST", "https://www.google.com/recaptcha/enterprise/reload?k="+siteKey, bytes.NewReader(reload)) req.Header.Set("user-agent", userAgent) req.Header.Set("content-type", "application/x-protobuffer") req.Header.Set("referer", anchorURL) resp, err = client.Do(req) if err != nil { return nil, err } text, _ := io.ReadAll(resp.Body) resp.Body.Close() token, err := ParseToken(text) if err != nil { return nil, err }
// 6. Hand the token to Ticketmaster. The response sets tmpt. view, _ := json.Marshal(map[string]string{"hostname": "www.ticketmaster.com", "key": siteKey, "token": token}) req, _ = http.NewRequest("POST", "https://www.ticketmaster.com/epsf/gec/v3/pageView", bytes.NewReader(view)) req.Header.Set("user-agent", userAgent) req.Header.Set("content-type", "application/json") req.Header.Set("referer", pageURL) resp, err = client.Do(req) if err != nil { return nil, err } resp.Body.Close() for _, cookie := range resp.Cookies() { if cookie.Name == "tmpt" { return cookie, nil } } return nil, fmt.Errorf("pageView %d: no tmpt", resp.StatusCode)}The gate page
Section titled “The gate page”Some pages, such as event pages, answer a new session with 401 and a gate page. The gate runs the same reCAPTCHA
check, posts the token to /epsf/gec/v3/Event, and loads the page again once tmpt is set. Follow the steps above with
these changes:
| Step | Change |
|---|---|
| 2 | The page answers 401 and sets no cookies. Fetch /eps-mgr with referer set to the page. It sets eps_sid, the only cookie the gate has. |
| 4 | Send "action": "Event", the page as page_url and an empty cookies array. Call us about 700 ms after you request the anchor: the gate posts its reload 0.6 to 0.9 seconds after it asks for the anchor. |
| 6 | Post the token to /epsf/gec/v3/Event, with referer set to the page and eps_sid as the only cookie. The body is the same, and the response sets tmpt. |
Then load the page again, with eps_sid and tmpt:
GET <the page's path> HTTP/2host: www.ticketmaster.comcache-control: max-age=0sec-ch-ua: "Google Chrome";v="155", "Chromium";v="155", "Not(A:Brand";v="24"sec-ch-ua-mobile: ?0sec-ch-ua-platform: "Windows"upgrade-insecure-requests: 1user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7sec-fetch-site: same-originsec-fetch-mode: navigatesec-fetch-dest: documentreferer: <the page>accept-encoding: gzip, deflate, br, zstdaccept-language: en-GB,en-US;q=0.9,en;q=0.8cookie: eps_sid=...; tmpt=...priority: u=0, iIt answers 200 with the page itself. If it answers 403, Ticketmaster has refused the session. Switch proxy and start
again.
Other Ticketmaster sites
Section titled “Other Ticketmaster sites”The same flow works on other Ticketmaster sites, such as www.ticketmaster.nl, www.eticketing.co.uk and
web-identity.tmtickets.co.uk. They use the same site key. Swap www.ticketmaster.com for the site’s host in these steps:
| Step | Change |
|---|---|
| 2 | Open a page on the site, then its /eps-mgr. |
| 3 | Set co to the site’s origin in Base64, for example https://www.eticketing.co.uk:443 is aHR0cHM6Ly93d3cuZXRpY2tldGluZy5jby51azo0NDM.. Set referer to the site’s origin with a trailing /. |
| 4 | Send the page you opened on the site as page_url, and the site’s cookies that are not HttpOnly. |
| 6 | Post to the site’s own /epsf/gec/v3/pageView, with hostname, origin and referer from the site. |
When it fails
Section titled “When it fails”| Status | Cause | What to do |
|---|---|---|
400 |
A field is missing or wrong, the user agent is not Chrome 145–155 on Windows, or the anchor page has expired (it lasts an hour). The message says which. | Fix it, or fetch a fresh anchor page. |
401 |
The API key is missing, wrong or out of balance. | Check the key. |
409 |
The anchor is from a reCAPTCHA version we do not support yet. | Fetch the anchor with the version from GET /config. |
501 |
This anchor asks for something we cannot build yet. Not billed. | Tell us. |
503 |
We are still loading your page_url, or the service is temporarily unavailable. |
Retry after a few seconds. |
If Google returns no rresp token, or Ticketmaster does not set tmpt, check that your session used one proxy and one
user agent throughout, and that your client matches Chrome.