How to Track Ticket Prices Across Multiple Marketplaces

1. Match events across marketplaces

First you need the event's URL on every marketplace. Each one gives the October 2 show its own ID, and two of them even name it differently:

• 160334460 on StubHub
• 6564648 on Vivid Seats
• 18027119 on SeatGeek, which calls it "Harry Styles with Jamie XX"
• 7695881 on TickPick, which calls it "Harry Styles & Jamie xx"

Matching these by hand is fine for one show, but it becomes slow and tedious once you track more than a few.

Tickets.dev keeps one identity per event across marketplaces. Search the free events API by name, or give it one marketplace URL, and you get the event back with its URL on each marketplace that lists it. The catalog has no rate limit. Try it:

2. Capture live inventory

Each link above is a page you can capture. Send it to the capture endpoint for that marketplace:

curl -G https://api.tickets.dev/v1/capture \
  --data-urlencode "url=https://www.stubhub.com/harry-styles-new-york-tickets-10-2-2026/event/160334460/" \
  -H "x-api-key: $TICKETS_DEV_KEY"

Tickets.dev loads the page live in a real browser and returns every listing: section, row, quantity, ticket price, fee and total. For the October 2 show, all four came back in under 9 seconds:

• 203 listings from StubHub
• 392 listings from SeatGeek
• 392 listings from TickPick
• 288 listings from Vivid Seats

No marketplace is cheapest across the board. TickPick had the cheapest ticket for the whole show and the priciest listing for those 8 seats:

• $160 on TickPick
• $166 on Vivid Seats
• $173 on SeatGeek
• $179.15 on StubHub

If you only need one ticket, look at singles: they're harder to sell, so sellers often price them lower. In the 31 rows that had both, the cheapest single beat the cheapest pair or group 23 times, and the median saving was 27%. In Section 118, Row 7, one seat on StubHub was $492.80, while pairs started at $798.

3. Normalize the listings

Before you can compare listings across marketplaces, they have to line up. Section names don't: the left side of the floor is "Left General Admission" on StubHub and TickPick, "left ga" on SeatGeek, and both "Left GA" and "LFTGA2" on Vivid Seats. Match on the section name as text and you'll miss it, so map names like these to one section before you compare.

The same tickets can also turn up more than once. The 8 seats from the top of this guide are one set of tickets listed on three marketplaces. Count them once.

The rest Tickets.dev lines up for you. Each marketplace's response is normalized into one listing schema: section, row, quantity, ticket price, fee and an all-in totalPrice you can compare directly. StubHub folds its fees into the listed price, so its fee is 0. Every endpoint returns that same snapshot, so one parser covers every marketplace.

{
  "listingId": "14278135569",
  "inventoryType": "resale",
  "section": "118",
  "row": "7",
  "quantity": 1,
  "ticketPrice": 492.8,
  "fee": 0,
  "totalPrice": 492.8,
  "ticketType": "Mobile ticket",
  "sellableQuantities": "1",
  "group": "100 Level",
  "seats": "",
  "listingNotes": "Third Row of Section, Clear view, Instant download",
  "dealScore": "7.38"
}

{
  "listingId": "VB15348332327",
  "inventoryType": "resale",
  "section": "118",
  "row": "7",
  "quantity": 2,
  "ticketPrice": 594,
  "fee": 208,
  "totalPrice": 802,
  "ticketType": "Ticketmaster Transfer",
  "sellableQuantities": "2",
  "group": "100 Level",
  "seats": "5,6",
  "listingNotes": "Please note that you will need to use an iOS or Android mobile device to gain entry to your event.",
  "dealScore": "4.4"
}

4. Track prices over time

Save each capture with a timestamp and you have a snapshot. Capture every marketplace on a schedule and the snapshots add up to price history for the whole event.

Capture more often as the show gets closer, since that's when prices move most. A week out, twice a day is plenty. On the last day, every hour.

Here's the whole tracker, filled in with the event picked in step 1. Every minute it checks which marketplaces are due, captures them through /v1/capture, and appends each snapshot to a file. If a capture fails, it tries again on the next pass.

import json
import os
import time
from datetime import datetime, timezone

import requests

API_KEY = os.environ["TICKETS_DEV_KEY"]
SHOW_STARTS = datetime.fromisoformat("2026-10-02T20:00:00-04:00")
EVENT_URLS = [
    "https://www.stubhub.com/harry-styles-new-york-tickets-10-2-2026/event/160334460/",
    "https://seatgeek.com/harry-styles-tickets/new-york-new-york-madison-square-garden-2026-10-02-8-pm/concert/18027119",
    "https://www.tickpick.com/buy-harry-styles-jamie-xx-tickets-madison-square-garden-10-2-26-8pm/7695881/",
    "https://www.vividseats.com/harry-styles-tickets-new-york-madison-square-garden-10-2-2026--concerts-pop/production/6564648",
]

# Capture more often as the show gets closer. Example numbers, tune to taste.
# (hours before the show, minutes between captures)
SCHEDULE = [
    (24 * 7, 12 * 60),  # more than a week out: twice a day
    (24, 3 * 60),       # the last week: every 3 hours
    (0, 60),            # the last day: every hour
]

# Each capture costs one credit. Stop after this many; raise it once a test
# run looks right.
MAX_CAPTURES = 50


def minutes_between_captures(hours_left):
    for hours, minutes in SCHEDULE:
        if hours_left >= hours:
            return minutes
    return SCHEDULE[-1][1]


def capture(url):
    response = requests.get(
        "https://api.tickets.dev/v1/capture",
        params={"url": url},
        headers={"x-api-key": API_KEY},
        timeout=120,
    )
    response.raise_for_status()
    return response.json()


last_capture = {}
captures = 0

while datetime.now(timezone.utc) < SHOW_STARTS and captures < MAX_CAPTURES:
    now = datetime.now(timezone.utc)
    hours_left = (SHOW_STARTS - now).total_seconds() / 3600
    every = minutes_between_captures(hours_left) * 60

    for url in EVENT_URLS:
        if captures >= MAX_CAPTURES:
            break
        if url in last_capture and (now - last_capture[url]).total_seconds() < every:
            continue  # not due yet
        try:
            snapshot = capture(url)
        except requests.RequestException as error:
            print(f"capture failed, will retry: {url} ({error})")
            continue

        last_capture[url] = now
        captures += 1
        with open("snapshots.jsonl", "a") as file:
            file.write(json.dumps(snapshot) + "\n")
        stats = snapshot["stats"]
        print(f"{snapshot['source']}: {stats['listingCount']} listings, "
              f"cheapest ${stats['getInPrice']}")

    time.sleep(60)

print(f"stopped after {captures} captures")

Each capture costs one credit, so the schedule is also your budget. With the numbers above, the final week is 72 captures per marketplace. The script also stops after MAX_CAPTURES (50 by default), so a test run can't overspend. Once you track more than a handful of events, swap snapshots.jsonl for a database.