# SeatGeek Scraper \[Only $3.5/1K💰] | Concert & Sports Price Data (`ahmed_jasarevic/seatgeek-scraper`) Actor

Extract SeatGeek events with live ticket price statistics — lowest, base, median, average and highest price, listing and ticket counts — from SeatGeek's own public API. No API key, no proxy, no browser. For resale research, price monitoring and event market sizing.

- **URL**: https://apify.com/ahmed_jasarevic/seatgeek-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### SeatGeek Scraper — Event Data With Live Ticket Price Statistics

Extract SeatGeek events with live resale price statistics — lowest, base, median, average and highest price, plus listing and ticket counts — from SeatGeek's own public Platform API, with no API key to supply, no proxy and no browser, from $3.5 per 1,000 events.

#### Main Use Cases

- **Resale ticket price research** — lowest / median / average / highest price per event for pricing strategy and market sizing.
- **Ticket price monitoring** — scheduled runs with `scrapedAt` timestamps let you diff median prices over time and catch price swings before they close.
- **Concert & tour discovery** — events filtered by performer slug, venue, city or taxonomy, with full venue address, coordinates and capacity.
- **Sports event data** — NBA / NFL / NHL / MLB schedules with parsed `AWAY at HOME` matchups and per-game price ranges.
- **Theater & Broadway data** — plays, musicals and comedy events with the same price statistics.
- **Event & venue market sizing** — venue capacity, city, state and coordinates for demand forecasting.

#### How the SeatGeek Scraper Works

The Actor reads **SeatGeek Platform API v2** — `https://api.seatgeek.com/2/events` and `/2/events/{id}` — SeatGeek's own documented public API. It sits on separate infrastructure from the marketing site, is fronted by a CDN and is **not** behind DataDome; it only needs a public `client_id`, which is **bundled in the Actor**, so runs work out of the box with no credential input. No browser is ever launched — it is a pure HTTP + JSON `CheerioCrawler`, which keeps it fast and cheap.

The bundled `client_id` tier matters: restricted public keys return the event catalogue with an **empty `stats` block** (events yes, prices no). The key here returns the complete statistics — `listing_count`, `ticket_count`, `lowest_price`, `median_price`, `average_price`, `highest_price` and `lowest_sg_base_price`.

### Get Event-Level Price Data Without a Browser or API Key

Each event row carries the full record: title, local and UTC datetimes, scheduling metadata, taxonomy, venue with address / city / state / country / lat-lon / capacity, performers with their taxonomy, popularity and score, the canonical event URL, and the `priceRange` block with `listingCount`, `ticketCount`, `visibleListingCount`, `lowestPrice`, `lowestBasePrice`, `medianPrice`, `averagePrice`, `highestPrice`, `currency` and `source`. For sports, the title's `AWAY at HOME` is parsed into a validated `sportsMatchup` object.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchQueries` | array of string | no | `["concert"]` | Free-text searches (`q`). Leave empty to browse everything matching other filters. |
| `eventUrls` | array of string (URL) | no | `[]` | Specific SeatGeek event URLs (event ID read from trailing path segment). **When set, only these events are scraped and every other filter is ignored.** |
| `venueIds` | array of string | no | `[]` | SeatGeek venue IDs, e.g. `[752]`. |
| `performerIds` | array of string | no | `[]` | Performer / team IDs, e.g. `[35]` (Taylor Swift) or `[2090]` (New York Knicks). |
| `performerSlugs` | array of string | no | `[]` | Performer slugs, e.g. `["taylor-swift"]`. |
| `taxonomyIds` | array of string | no | `[]` | Category IDs: 1000000 concerts, 1030000 sports, 3010000 theater, 1030300 basketball, and more. Empty = all. |
| `venueCity` | string | no | `""` | Only events whose venue is in this city. |
| `venueState` | string | no | `""` | Only events whose venue is in this US state code. |
| `venueCountry` | string | no | `""` | Only events in this ISO country code. |
| `dateFrom` | string (ISO 8601) | no | today | Only events starting at/after this time (`datetime_utc.gte`). |
| `dateTo` | string (ISO 8601) | no | – | Only events starting before this time (`datetime_utc.lt`). |
| `onlyOpen` | boolean | no | `true` | Only events currently on sale. Set `false` to include past / not-yet-on-sale events. |
| `sort` | string (select) | no | `datetime_utc.asc` | `datetime_utc.asc`, `datetime_utc.desc`, `popularity.asc`, `popularity.desc`. |
| `maxItems` | integer | no | `100` | **The only limit you need to set.** Max unique events; paging and rate limiting are handled automatically. |

### Output: Event Rows and a Run Summary

Two record types share one dataset, distinguished by `recordType`. Event rows are written as each event is discovered, so a killed run still returns everything fetched so far. A `runSummary` row is written only on a clean finish.

| Field | Description |
|---|---|
| `eventId` | SeatGeek event ID. |
| `title`, `shortTitle` | Event title. |
| `eventUrl`, `relativeUrl` | Canonical SeatGeek URL. |
| `datetimeLocal`, `datetimeUtc`, `endDatetimeUtc` | Datetimes (venue-local and UTC). |
| `dateTbd`, `timeTbd`, `timezone`, `announceDate`, `onsale` | Scheduling metadata. |
| `eventType`, `taxonomies`, `primaryTaxonomy` | Category (`concert`, `nba`, `theater`, …). |
| `venueName`, `venueSlug`, `venueUrl`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `venuePostalCode`, `venueDisplayLocation` | Venue + city. |
| `venueCapacity`, `venueLat`, `venueLon` | Venue metadata for market sizing. |
| `performers[]` | `{ id, name, shortName, slug, isPrimary, url, taxonomies }` per performer. |
| `performerNames[]`, `primaryPerformer` | Flat performer list. |
| `sportsMatchup` | `{ away, home }` for sports (parsed from the `AWAY at HOME` title, validated against the performer list). `null` for non-sports. |
| `gameNumber`, `playoffs`, `seasonStage` | Sports scheduling. |
| **`priceRange`** | **`{ listingCount, ticketCount, visibleListingCount, lowestPrice, lowestBasePrice, medianPrice, averagePrice, highestPrice, currency, source }`** — SeatGeek's own server-side statistics. |
| `popularity`, `score` | SeatGeek demand signals — useful for ranking what to resell. |
| `recordType: "runSummary"` | `eventsProcessed`, `note`, `scrapedAt` — one row per clean run. |

Example `recordType: "event"` row (trimmed):

```json
{
  "recordType": "event",
  "eventId": "1234567",
  "title": "Taylor Swift: The Eras Tour",
  "shortTitle": "The Eras Tour",
  "eventUrl": "https://seatgeek.com/taylor-swift-tickets/crowdcast/the-eras-tour-1234567",
  "datetimeLocal": "2026-08-14T19:30:00",
  "datetimeUtc": "2026-08-14T23:30:00Z",
  "eventType": "concert",
  "primaryTaxonomy": { "id": 1000000, "name": "Concerts" },
  "venueName": "MetLife Stadium",
  "venueCity": "East Rutherford",
  "venueState": "NJ",
  "venueCountry": "US",
  "venueCapacity": 82500,
  "venueLat": 40.8135,
  "venueLon": -74.0745,
  "performers": [
    { "id": 35, "name": "Taylor Swift", "slug": "taylor-swift", "isPrimary": true }
  ],
  "primaryPerformer": "Taylor Swift",
  "sportsMatchup": null,
  "priceRange": {
    "listingCount": 1840,
    "ticketCount": 6210,
    "visibleListingCount": 1840,
    "lowestPrice": 61,
    "lowestBasePrice": 55,
    "medianPrice": 189,
    "averagePrice": 214,
    "highestPrice": 1250,
    "currency": "USD",
    "source": "seatgeek-api-stats"
  },
  "popularity": 97,
  "scrapedAt": "2026-09-27T10:00:00.000Z"
}
```

### Example Input

Broad sweep of upcoming concerts in New York:

```json
{
  "searchQueries": [],
  "venueCity": "New York",
  "taxonomyIds": ["1000000"],
  "maxItems": 200
}
```

Specific performer:

```json
{
  "performerSlugs": ["taylor-swift"],
  "maxItems": 20
}
```

### Pricing: From $3.5 per 1,000 Events

Event data and price statistics come from SeatGeek's public API with **no paid anti-bot service, no proxy and no browser**. The Actor runs at 256 MB, and a typical 100-event run costs well under 0.001 CU.

- **Start:** $0.00005 per run
- **Result:** **$0.0035 — $3.50 per 1,000 events** (same on free and bronze; $0.0034 on silver and above)
- **Free tier:** capped at 10 events per run.
- **No proxy needed**, so no proxy cost.

### Integrations & Automation

Runs on the Apify platform with **REST API access, webhooks, scheduled runs, dataset exports (JSON, CSV, Excel) and Zapier/Make integrations**. Recommended schedules:

- **Ticket price monitoring:** daily run per market with `sort: datetime_utc.asc`; diff `priceRange.medianPrice` between runs.
- **On-sale alerts:** short-interval runs on a specific `performerSlugs` with `onlyOpen: true` to catch newly listed inventory.
- **Market sizing:** monthly city/category sweeps with venue capacity and coordinates for demand forecasting.

### Related Actors

- [**Ticketmaster Events Scraper**](https://apify.com/e-commerce/ticketmaster-events-scraper) — Ticketmaster primary-market events and venues; the complement to SeatGeek's resale statistics.
- [**Ticketmaster Scraper**](https://apify.com/solidcode/ticketmaster-scraper) — Ticketmaster event and venue data across marketplaces.
- [**Ticketmaster Scraper (seat-level inventory)**](https://apify.com/lentic_clockss/ticketmaster-scraper) — Ticketmaster with per-seat listings, the data SeatGeek does not expose.
- [**Songkick Concert Calendar Scraper**](https://apify.com/abotapi/songkick-concert-calendar-scraper) — concert calendars for event discovery.
- [**Event Ticket Scraper**](https://apify.com/labrat011/event-ticket-scraper) — event tickets via an Apify MCP server, callable from AI agents.

### FAQ

#### Is there a SeatGeek API — and do I need a key?

Yes: SeatGeek's documented **Platform API v2** (`api.seatgeek.com/2/events`) needs only a public `client_id` parameter. This Actor **bundles a working client_id**, so you supply no credential at all. (Some other SeatGeek actors require you to register a client ID yourself — and a restricted key returns events with an empty `stats` block, meaning no prices.)

#### Why are there no per-seat ticket listings?

Per-seat inventory (section, row, seat, quantity, per-listing fees) exists only on SeatGeek's web host, which runs a **DataDome** challenge, and SeatGeek states it has no plans to expose individual listings via API. Every bypass was tested and measured — plain requests, a verified residential IP, Apify's paid Unblocker, and a stealth Camoufox browser — and all were refused, so it is neither an IP-reputation nor a TLS-fingerprint problem. The feature was therefore **removed** rather than left as a switch that silently returns nothing. If you need per-seat inventory, use SeatGeek's Seller API or a dedicated ticketing-data provider.

#### What are alternatives to this SeatGeek scraper?

Other Store actors target SeatGeek (`ai_solutionist/seatgeek-data-api`, `abotapi/seatgeek-events-scraper`, `hoholabs/seatgeek-scraper`, `crawlerbros/seatgeek-scraper`) — several are cheaper per result but require you to obtain and supply your own client ID, and some advertise per-seat listings that SeatGeek does not actually expose. For primary-market listings rather than resale prices, see the Ticketmaster actors in Related Actors.

#### How do I build ticket price history?

Run the Actor on a schedule. Every row carries `scrapedAt`, so load the dated datasets and diff `priceRange.medianPrice` / `lowestPrice` over time. The `runSummary` row (with `eventsProcessed`) is written only on a clean finish — filter on `recordType` accordingly.

#### What is the `sportsMatchup` field and how is it derived?

SeatGeek titles sports events `AWAY at HOME`. The Actor parses the title (stripping season prefixes and trailing parentheticals) and validates both sides against the event's performer list, falling back to `performer_order` only when the title is unparseable. Non-sports events return `null`.

#### Is scraping SeatGeek legal?

The Actor reads SeatGeek's own public, documented API. You are responsible for complying with SeatGeek's Terms of Service and for how you use the data.

### For AI Agents & LLM Apps

**Purpose:** returns one dataset row per SeatGeek event with SeatGeek's own aggregate resale price statistics (lowest / base / median / average / highest price, listing count, ticket count), venue, performers and datetimes.

Minimal working input:

```json
{ "searchQueries": ["comedy"], "maxItems": 20 }
```

Variants:

- City + category sweep: `{ "searchQueries": [], "venueCity": "New York", "taxonomyIds": ["1000000"], "maxItems": 200 }`
- Performer lookup: `{ "performerSlugs": ["taylor-swift"], "maxItems": 20 }`
- Exact events: `{ "eventUrls": ["https://seatgeek.com/.../1234567"], "maxItems": 10 }`

Output field list (event rows): `recordType`, `eventId`, `title`, `shortTitle`, `eventUrl`, `relativeUrl`, `datetimeLocal`, `datetimeUtc`, `endDatetimeUtc`, `dateTbd`, `timeTbd`, `timezone`, `announceDate`, `onsale`, `eventType`, `taxonomies`, `primaryTaxonomy`, `venueName`, `venueSlug`, `venueUrl`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `venuePostalCode`, `venueDisplayLocation`, `venueCapacity`, `venueLat`, `venueLon`, `performers`, `performerNames`, `primaryPerformer`, `sportsMatchup`, `gameNumber`, `playoffs`, `seasonStage`, `priceRange` (with `listingCount`, `ticketCount`, `visibleListingCount`, `lowestPrice`, `lowestBasePrice`, `medianPrice`, `averagePrice`, `highestPrice`, `currency`, `source`), `popularity`, `score`, `scrapedAt`.
Plus one `recordType: "runSummary"` row per clean finish (`eventsProcessed`, `note`, `scrapedAt`).

Behaviors an agent should know:

- **No API key input** — the `client_id` is bundled; there is nothing to configure.
- **No per-seat inventory exists in the output** — `priceRange` aggregates only; do not expect section/row/seat.
- **`eventUrls` overrides all other filters** — when set, every other input is ignored.
- **`searchQueries` prefills `["concert"]`** — set it to `[]` to browse by city/category/date instead of defaulting to concerts.
- **`onlyOpen: true` (default)** excludes past and not-yet-on-sale events; set `false` to include them.
- **Rate limit:** the Actor is hard-capped at 70 requests/min (API allows 100); paging and rate limiting are handled automatically, so `maxItems` is the only limit to set.
- **Filter rows on `recordType`** — `event` vs `runSummary` share one dataset; a `runSummary` row exists only on a clean finish.

**Billing:** pay-per-result — start $0.00005, then $0.0035 per event ($3.50 per 1K events); free tier caps at 10 events.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by SeatGeek**. It reads only data SeatGeek serves through its own public, documented Platform API v2 — no login bypass, no CAPTCHA solving, no private endpoints and no scraping of the protected web host. You are responsible for complying with SeatGeek's Terms of Service and with any contractual restrictions, and for how you use the event, venue and price data. This information is not legal advice.

### SEO Keywords

seatgeek scraper, seatgeek api, seatgeek event data, ticket price statistics, resale ticket prices, concert ticket prices data, sports event ticket data, nba ticket prices, nfl nhl nba schedule data, theater event data, broadway ticket data, ticket price monitoring, event market research, median ticket price, ticket price benchmark, performer tour dates data, venue capacity data, ticket resale market analysis, event ticket price history, seatgeek api key free, seatgeek alternatives, concert event discovery api, ticket inventory api, event data for promoters

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text searches passed to the SeatGeek events API as `q`. Leave empty to browse all events matching the other filters.

## `eventUrls` (type: `array`):

Specific SeatGeek event URLs (the event ID is read from the trailing path segment). When provided, only these events are scraped and every other filter is ignored.

## `venueIds` (type: `array`):

SeatGeek venue IDs, e.g. \[752] (Clowes Memorial Hall).

## `performerIds` (type: `array`):

SeatGeek performer IDs, e.g. \[35] (Taylor Swift) or \[2090] (New York Knicks).

## `performerSlugs` (type: `array`):

SeatGeek performer slugs, e.g. \["taylor-swift"].

## `taxonomyIds` (type: `array`):

SeatGeek taxonomy IDs. 1000000=Concerts, 1030000=Sports, 3010000=Theater, 3010200=Musicals, 3010100=Plays, 3010300=Comedy, 1030200=Baseball, 1030300=Basketball, 1030100=Football, 1030400=Hockey, 1040000=Family, 1050000=Other. Leave empty for all categories.

## `venueCity` (type: `string`):

Restrict results to events whose venue is in this city.

## `venueState` (type: `string`):

Restrict results to events whose venue is in this US state code.

## `venueCountry` (type: `string`):

Restrict results to events in this ISO country code.

## `dateFrom` (type: `string`):

Only events starting at or after this date/time (ISO 8601). Sent as `datetime_utc.gte`.

## `dateTo` (type: `string`):

Only events starting before this date/time (ISO 8601). Sent as `datetime_utc.lt`.

## `onlyOpen` (type: `boolean`):

When true (default) only events that are open for ticket sales are returned. Set to false to include past / not-yet-on-sale events.

## `sort` (type: `string`):

Sort order for the events endpoint.

## `maxItems` (type: `integer`):

Maximum number of unique events to return in this run. This is the only limit you need to set - the Actor handles paging and rate limiting automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "concert"
  ],
  "eventUrls": [],
  "venueIds": [],
  "performerIds": [],
  "performerSlugs": [],
  "taxonomyIds": [],
  "onlyOpen": true,
  "sort": "datetime_utc.asc",
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "concert"
    ],
    "eventUrls": [],
    "venueIds": [],
    "performerIds": [],
    "performerSlugs": [],
    "taxonomyIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/seatgeek-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["concert"],
    "eventUrls": [],
    "venueIds": [],
    "performerIds": [],
    "performerSlugs": [],
    "taxonomyIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/seatgeek-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "concert"
  ],
  "eventUrls": [],
  "venueIds": [],
  "performerIds": [],
  "performerSlugs": [],
  "taxonomyIds": []
}' |
apify call ahmed_jasarevic/seatgeek-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/seatgeek-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JEt4rakEHiwbpYgxA/builds/Ae0bkhPsSp164LRVK/openapi.json