# SeatGeek Scraper - Events, Tickets & Venues (`abotapi/seatgeek-events-scraper`) Actor

Scrape SeatGeek events with ticket price ranges (lowest, highest, average, median), venues, performers, dates and availability. Search by keyword, category, team, venue or date, or paste event links. Incremental monitoring, resume and MCP export.

- **URL**: https://apify.com/abotapi/seatgeek-events-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 event, performer or venue records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SeatGeek Scraper

Scrapes SeatGeek, the US ticket marketplace: upcoming events with the
source's own ticket price statistics (lowest, highest, average and median
price, plus listing and ticket counts), venues, and performers (teams,
artists, leagues). Search by keyword, category, performer, venue or date
range, or paste SeatGeek links.

### Quick start

1. Pick **Search** mode, type a keyword (for example `coldplay`) and run.
   You get the matching upcoming events with their price ranges.
2. Or pick **URL mode** and paste SeatGeek links: event pages (they end in
   the event id), performer pages (they end in `-tickets`) or venue pages
   (they start with `/venues/`). Event links return one record; performer
   and venue links return every upcoming event there.

#### Input summary

| Field | Type | Default | Meaning |
|---|---|---|---|
| `mode` | select | `search` | Keyword search or paste links. |
| `query` | string | `coldplay` | Search mode: the keyword to look up. |
| `searchType` | select | `events` | Search mode: `events`, `performers` or `venues`. |
| `taxonomy` | select | empty | Events search only: narrow to `concert`, `sports`, `theater`, `family` or `comedy`. |
| `performerIds` | string list | empty | Events search only: numeric performer ids; returns events featuring any of them. |
| `venueId` | string | empty | Events search only: numeric venue id; returns events at that venue. |
| `dateFrom` / `dateTo` | string | empty | Events search only: date bounds in `YYYY-MM-DD` form. |
| `sort` | select | empty | Events search only: date, popularity or ticket price ordering. |
| `urls` | string list | one example link | URL mode: the SeatGeek pages to read. |
| `maxItems` | integer | `20` | Stop after this many records; `0` means no limit. |
| `maxPages` | integer | `0` | Page cap per scope; `0` (the default) walks until results run out. |
| `proxyConfiguration` | proxy | Apify proxy | The default works on every plan. |

The Events-only filters (`taxonomy`, `performerIds`, `venueId`, `dateFrom`,
`dateTo`, `sort`) sit in the Search mode input section and are applied when
the listing URL is built, so they only take effect with **Search type:
Events**. They are ignored by the Performers and Venues directory searches,
which is exactly what each field's description says.

#### Output

Every dataset row carries a `kind` field:

- `kind: "event"`: one dated occurrence with `title`, `startDateTimeUtc`,
  venue block (`venueName`, `venueCity`, coordinates, capacity, timezone),
  `performers` (with the `headliner`), `taxonomies`, and the source's own
  price statistics: `lowestPrice`, `highestPrice`, `averagePrice`,
  `medianPrice`, `goodDealLowestPrice`, `listingCount`, `ticketCount`.
- `kind: "performer"`: a directory entry with `name`, `performerType`,
  `numUpcomingEvents`, image and profile link.
- `kind: "venue"`: a directory entry with `name`, `city`, `state`,
  `capacity`, coordinates and upcoming-event counts.

Sample rows (illustrative placeholders, not from a live listing):

```json
{
  "kind": "event",
  "recordId": "event:99990001",
  "title": "The Marble Foxes at Riverside Amphitheater",
  "eventType": "concert",
  "startDateTimeUtc": "2027-03-14T23:30:00",
  "venueName": "Riverside Amphitheater",
  "venueCity": "Harborview",
  "lowestPrice": 45.0,
  "highestPrice": 210.0,
  "averagePrice": 88.0,
  "listingCount": 132
}
```

```json
{
  "kind": "venue",
  "recordId": "venue:99990002",
  "name": "Grand Plaza Arena",
  "city": "Midtown",
  "capacity": 19500,
  "numUpcomingEvents": 42
}
```

### What is covered, and what is not

- **No reviews or social surface exists on this source**: the marketplace
  does not publish user reviews for events or venues through the data
  interface this actor reads, so none are returned. Nothing is invented.
- **Per-ticket listings are not covered**: the individual ticket offers
  behind each event require an authenticated account on the source. The
  actor returns each event's aggregated price statistics instead, which the
  open data interface publishes for every event.
- Event links must be public SeatGeek pages; password-protected or
  region-blocked pages cannot be read.

### Resume and recurring updates

Two related but different features live in the same input section:

- **Resume (`resumeFromRunId`)**: paste a previous run ID or dataset ID and
  the actor skips records already collected there. Use it to continue one
  large pull that was interrupted.
- **Incremental mode (`incrementalMode`)**: for scheduled monitoring. The
  first run returns everything as `NEW`. Later runs return only `NEW`,
  `UPDATED` and `REAPPEARED` rows, each stamped with `changeType`,
  `changedFields`, `firstSeenAt` and `lastSeenAt`. Rows that vanish are
  marked `EXPIRED` (with `emitExpired`), but only after a run that scanned
  the whole search without caps or errors.

Note on change detection: ticket prices and listing counts move hourly, so
they are deliberately excluded from the change fingerprint. A price move
alone does not produce an `UPDATED` row; a new date, a reschedule, a new
venue or a status change does. The live price values are always in the
emitted rows.

### Send results into your apps (MCP connectors)

You can optionally pipe results into apps you already use via Model Context
Protocol (MCP) connectors. Authorize a connector under Apify, Settings,
API & Integrations, then select it in the `mcpConnectors` input field. For
Notion, set `notionParentPageUrl` to the page under which item pages are
created; the Notion export writes a page per record with a readable
summary. Other connectors get a best-effort write or digest.

Each connector receives a condensed, human-readable summary per record
(title plus the key fields flattened to plain text), not the full record.
The complete record always stays in the Apify dataset. Use
`maxNotifyListings` to cap how many items each connector receives per run.
Leave `mcpConnectors` empty to skip the export entirely; the dataset output
is never changed by the connector surface.

### Limits and notes

- The events interface returns at most 100 records per page; the actor
  walks page by page until `maxItems` or the natural end of the results.
- A run whose every request was rejected fails loudly with a connection
  problem message; a search that genuinely matches nothing succeeds quietly
  with a status message. The two are never confused.
- Results are deduplicated across scopes and pages by record id.

# Actor input Schema

## `mode` (type: `string`):

Search looks up events, performers or venues by keyword. URL mode reads specific SeatGeek pages you paste.

## `query` (type: `string`):

Search mode: a keyword, for example an artist, team, venue or city name. Used with Search type below.

## `searchType` (type: `string`):

Search mode: what the keyword should find. Events returns upcoming events. Performers returns team, artist and league entries. Venues returns venue entries.

## `taxonomy` (type: `string`):

Events search type only: narrow the events to one broad category. Leave empty for all categories.

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

Events search type only: numeric SeatGeek performer ids (teams, artists, leagues). Events featuring any of them are returned. Example: 8 for the New York Yankees.

## `venueId` (type: `string`):

Events search type only: a numeric SeatGeek venue id. Only events at that venue are returned. Example: 35 for Madison Square Garden.

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

Events search type only: only events on or after this date (YYYY-MM-DD).

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

Events search type only: only events on or before this date (YYYY-MM-DD).

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

Events search type only: the order events are returned in. Defaults to soonest first.

## `urls` (type: `array`):

URL mode: SeatGeek pages to read, one per line. Event links (they end in the event id) are read as one record; performer pages (they end in -tickets) and venue pages (/venues/...) are resolved and their upcoming events are walked. Multi-value supported.

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

Stop after this many records (0 = no limit; the run then stops when the results run out).

## `maxPages` (type: `integer`):

Upper bound on how many pages each search or link is walked through. Defaults wide open so Max items is the only cap that stops a run early.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning records already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching record as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED records. Ticket price statistics are excluded from change detection (they move hourly), so a price move alone is not an UPDATED row. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search and link settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. The prefilled default works on every Apify plan.

## Actor input object example

```json
{
  "mode": "search",
  "query": "coldplay",
  "searchType": "events",
  "urls": [
    "https://seatgeek.com/new-york-yankees-tickets"
  ],
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "query": "coldplay",
    "searchType": "events",
    "urls": [
        "https://seatgeek.com/new-york-yankees-tickets"
    ],
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/seatgeek-events-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 = {
    "mode": "search",
    "query": "coldplay",
    "searchType": "events",
    "urls": ["https://seatgeek.com/new-york-yankees-tickets"],
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/seatgeek-events-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 '{
  "mode": "search",
  "query": "coldplay",
  "searchType": "events",
  "urls": [
    "https://seatgeek.com/new-york-yankees-tickets"
  ],
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/seatgeek-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/seatgeek-events-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/Hp4by2OVosXxu9tkp/builds/osNbN5CpGvFDBxULf/openapi.json