API reference

Introduction

The tickets.dev API scrapes live marketplace inventory on demand. There is no crawl to schedule and no cache to go stale: each call opens the event, reads its current listings and prices, and returns the result to you. Ask for the seat maps and it renders those too.

Learn the product concepts in the ticket scraping API, ticket inventory API, and ticket price API guides.

All endpoints live under a single base URL and speak JSON.

https://api.tickets.dev/v1

Authentication

Every request must carry your API key. Send it in the x-api-key header. Create a key from the account page.

curl -G https://api.tickets.dev/v1/capture/ticketmaster \
  --data-urlencode "url=$EVENT_URL" \
  -H "x-api-key: $TICKETS_DEV_KEY"

An apiKeyquery parameter is accepted as well, for callers that can't set a header.

Sandbox

There is no separate sandbox host. Same base URL, same paths, same query parameters, same snapshot shape. One public key returns fixtures instead of a live capture.

tk_test_sandbox

Build against that key. Cut over by swapping it for your org's tk_live_… key. Nothing else in the request should have to change: not the URL, not the query, not the parser.

curl -G https://api.tickets.dev/v1/capture/ticketmaster \
  --data-urlencode "url=https://www.ticketmaster.com/event/example" \
  -H "x-api-key: tk_test_sandbox"

Validation still runs, so a bad URL, a marketplace mismatch, or a restricted source fails the same way it would in production. The JSON body does not advertise sandbox, because that would leak into client parsers. Responses include the header Tickets-Sandbox: true. Streaming captures send the same progress events, then a snapshot event with that same body.

Quickstart

Point the API at any supported event URL. The request runs the capture and returns the finished result.

curl -G https://api.tickets.dev/v1/capture/ticketmaster \
  --data-urlencode "url=https://www.ticketmaster.com/event/XXXXXXXX" \
  -H "x-api-key: $TICKETS_DEV_KEY"

Endpoints

Pass an event URL and every marketplace returns the identical snapshotobject. The marketplace is optional: it comes from the URL's host unless you name it with source= or in the path.

Parameters

The snapshot object

Every capture returns one snapshot. It carries the event metadata, the currency, the derived stats, the flat list of listings, and URLs to the rendered seat maps.

{
  "source": "ticketmaster",
  "eventId": "17006483D6FAFC60",
  "eventName": "Eagles Live at Sphere",
  "venueId": "189524",
  "venueName": "Sphere",
  "venueCity": "Las Vegas",
  "venueState": "NV",
  "venueTimezone": "America/Los_Angeles",
  "eventDateLocal": "2026-12-11T20:30:00-08:00",
  "eventDateUtc": "2026-12-12T04:30:00+00:00",
  "currency": "USD",
  "sectionLevelUrl": "https://storage.tickets.dev/…/section.svg",
  "seatLevelUrl": "https://storage.tickets.dev/…/seats.svg",
  "stats": {
    "listingCount": 136,
    "ticketCount": 1037,
    "getInPrice": 303.08,
    "medianPrice": 710.95,
    "avgPrice": 746.14,
    "maxPrice": 2309.85
  },
  "listings": [{
    "listingId": "",
    "inventoryType": "primary",
    "section": "208",
    "row": "9",
    "quantity": 3,
    "ticketPrice": 1157.5,
    "fee": 208.35,
    "totalPrice": 1365.85,
    "sellableQuantities": "1,2,3"
  }]
}

The stats object

Everything else in a snapshot is what the marketplace said; stats is what we worked out from it. Every figure is per-ticket and all-in, the same basis as totalPrice, so they compare cleanly across marketplaces, and every statistic is per listing, not per seat: a ten-seat listing counts once, exactly as it appears once on the marketplace. A capture with no listings reports zeroes, never null.

The listing object

Each entry in listings is one group of same-price seats. Every field below comes back from every marketplace; a source that also exposes something of its own (a deal score, a seat-view photo, a map pin) adds it alongside them.

Seat maps

Pass includeVenueMaps=true and the capture renders two SVGs and hosts them for you:

• sectionLevelUrl, the overview: the venue outline, the stage, and one shape per section.
• seatLevelUrl, the zoomed detail, as fine as that marketplace draws it: one mark per seat on Ticketmaster and SeatGeek, one shape per row on StubHub, viagogo and TickPick.

The two share a viewBox. The seat file is a single group in the section map's own coordinates, so you render the overview and append the detail to the same <svg> when someone zooms in: no transform, and a viewer that never zooms never fetches it. That split matters: a venue's sections are tens of kilobytes, its seats hundreds.

Every region on both carries data-section, and data-row where the source has rows, spelled exactly the way listings[].section spells it in the same response, so you can bind a listing to its shape by name and shade it by price or availability without a lookup table.

Without the parameter both fields come back as empty strings. The fields are always present, so a client never has to branch on their existence. seatLevelUrl is also empty where the marketplace publishes nothing below the section, which is the case on Vivid Seats and Gametime. Either way the rest of the snapshot comes back normally: a map that can't be rendered never fails a capture.

curl -G https://api.tickets.dev/v1/capture/ticketmaster \
  --data-urlencode "url=$EVENT_URL" \
  --data-urlencode "includeVenueMaps=true" \
  -H "x-api-key: $TICKETS_DEV_KEY"

Marketplaces

Every marketplace returns the same snapshot. Pass an event URL from one of its domains and the marketplace is worked out for you. The paths below are the explicit form, and the last segment of each is also the value for source=:

Marketplace	Path	Event URL domains
Ticketmaster API	/v1/capture/ticketmaster	ticketmaster.com, livenation.com
Vivid Seats API	/v1/capture/vividseats	vividseats.com
StubHub API	/v1/capture/stubhub	stubhub.com
SeatGeek API	/v1/capture/seatgeek	seatgeek.com
TickPick API	/v1/capture/tickpick	tickpick.com
Gametime API	/v1/capture/gametime	gametime.co
Viagogo API	/v1/capture/viagogo	viagogo.com
GoTickets API	/v1/capture/gotickets	gotickets.com
Paciolan API	/v1/capture/paciolan	evenue.net

An event URL from a domain we don't recognize is still accepted, so regional partners and link shorteners work, as long as you name the marketplace, since there is nothing to infer from otherwise. Without a name such a URL returns marketplace_required. And a URL that clearly belongs to a different marketplace than the one you named is rejected with marketplace_mismatch rather than captured against the wrong source.

Errors

Every error carries a stable code and the request_id that also comes back in the x-request-id header. Branch on the code, not the status: several distinct failures share a status, and the code is what tells you whether retrying is worth it.

{
  "error": {
    "code": "marketplace_mismatch",
    "message": "Requested source \"stubhub\" but the URL is a ticketmaster event.",
    "request_id": "6068316c-29d3-447f-b42c-b46f80debd0d"
  }
}

Rate limits

Each plan adds captures each invoice and sets a ceiling on how many captures can run at once. Spending them returns 429 quota_exceeded; whatever is left stays on your balance. See the pricing table for the limits on every tier.