# SeatGeek Scraper (`crawlerbros/seatgeek-scraper`) Actor

Scrape SeatGeek - search live event listings by artist, team, or venue, or browse 156 sports/concert/theater categories. Get event date, venue, price range, and ticket counts.

- **URL**: https://apify.com/crawlerbros/seatgeek-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

Scrape [SeatGeek](https://seatgeek.com) — the ticket resale marketplace and event
aggregator covering sports, concerts, theater/Broadway, and comedy. Search by
artist / team / venue name, or browse any of 156 real SeatGeek categories. Get
event date, venue address, price range, and ticket/listing counts — no login,
no API key, no cookies required.

### What this actor does

- **Three modes:** `search` (artist/team/venue name), `byCategory` (156 real SeatGeek
  categories), `byUrl` (fetch specific `seatgeek.com` URLs directly)
- **Rich pricing data:** lowest / highest / average / median ticket price and live
  listing & ticket counts, straight from SeatGeek's own event data
- **Filters:** date range, price range, venue city/state, sort order
- **Empty fields are omitted** — every record only contains fields SeatGeek actually
  provided

### Output per event

- `eventId`, `eventTitle`
- `eventDate` (`YYYY-MM-DD`), `eventDateTimeLocal`, `eventDateTimeUtc`, `dateTbd`
- `venueName`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `venuePostalCode`, `venueCapacity`
- `venueLatitude`, `venueLongitude`, `venueTimezone`, `venueUrl`
- `performers[]`, `primaryPerformer`
- `category`, `categorySlug`
- `priceMin`, `priceMax`, `priceAverage`, `priceMedian`, `currency`
- `listingCount`, `ticketCount`
- `thumbnailUrl`
- `isOpen`, `isRescheduled`, `eventStatus`, `announceDate`
- `popularityScore` (SeatGeek's own 0–1 popularity ranking for the event)
- `listingUrl`, `sourceUrl`
- `recordType: "event"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byUrl` |
| `searchQuery` | string | `New York Yankees` | Artist, team, or venue name (mode=search) |
| `category` | string | `nba` | One of 156 SeatGeek categories (mode=byCategory) |
| `startUrls` | array | – | Direct `seatgeek.com` URLs (mode=byUrl) |
| `dateFrom` | string | – | Only events on/after this date (`YYYY-MM-DD`) |
| `dateTo` | string | – | Only events on/before this date (`YYYY-MM-DD`) |
| `minPrice` | int | – | Only events with a lowest ticket price ≥ this |
| `maxPrice` | int | – | Only events with a lowest ticket price ≤ this |
| `city` | string | – | Only events at a venue in this city |
| `state` | string | – | Only events at a venue in this US state code |
| `sortBy` | string | `relevance` | `relevance` / `date` / `priceLow` / `priceHigh` / `popularity` |
| `maxItems` | int | `20` | Hard cap on emitted records (1–500) |
| `proxyConfiguration` | object | AUTO | Optional; used automatically only if a request is blocked |

#### Example: search by team name

```json
{
  "mode": "search",
  "searchQuery": "New York Yankees",
  "maxItems": 20
}
````

#### Example: browse NFL tickets, sorted by price

```json
{
  "mode": "byCategory",
  "category": "nfl",
  "sortBy": "priceLow",
  "maxItems": 50
}
```

#### Example: filter concerts by date and price range

```json
{
  "mode": "byCategory",
  "category": "concerts",
  "dateFrom": "2026-08-01",
  "dateTo": "2026-12-31",
  "minPrice": 50,
  "maxPrice": 300
}
```

### Use cases

- **Ticket price tracking** — monitor lowest-price trends for a team, artist, or venue
- **Event discovery** — build a feed of upcoming events in a category, city, or state
- **Market research** — compare listing counts and price spreads across categories
- **Fan tools** — power a "get notified" price-drop alert for a favorite performer
- **Venue analytics** — pull every upcoming event at a specific venue

### FAQ

**Do I need a SeatGeek account or API key?** No. This actor scrapes SeatGeek's
public event pages directly — no login, cookies, or API key required.

**How does `search` work?** SeatGeek doesn't expose a public full-text search API
outside its own JavaScript-driven site search. This actor uses SeatGeek's own SEO
URL convention instead — every artist, team, and venue has a canonical
`seatgeek.com/{name}-tickets` page — so a query like `"New York Yankees"` resolves
directly to `seatgeek.com/new-york-yankees-tickets`. This covers the vast majority
of real searches (exact and near-exact artist/team/venue names). Very ambiguous or
misspelled queries may not resolve; use `byCategory` or a `startUrls` link instead
in that case.

**What categories are available?** All 156 categories SeatGeek itself organizes
events into — every major sports league (NBA, NFL, MLB, NHL, MLS, NCAA divisions,
minor leagues, etc.), concerts, Broadway/theater, comedy, festivals, and more. See
the `category` dropdown for the full list.

**Is "Deal Score" included?** SeatGeek's per-listing Deal Score is only computed on
individual ticket-listing rows inside an event's live inventory view, which is
loaded by a heavier, more aggressively bot-protected endpoint than the category/
performer/venue listing pages this actor reads. It is not part of the event-level
data returned here. `priceMin` / `priceMax` / `priceAverage` / `priceMedian` and
`listingCount` / `ticketCount` — SeatGeek's own aggregate pricing signals — are
included instead.

**How many events come back per query?** SeatGeek server-renders a bounded set of
upcoming events per page (typically 10–75 depending on how many a team/artist/
category currently has scheduled); further results load client-side via a "Show
more" button that isn't part of the public page payload. For large categories
(e.g. `concerts`) this is still commonly 100+ events per run.

**Why do some categories or searches return 0 results?** SeatGeek only lists
currently scheduled *upcoming* events. An out-of-season sports league (e.g. NBA in
the summer) or an artist between tours will legitimately have zero listed events.

**Does it include venue map coordinates?** Yes — `venueLatitude` / `venueLongitude`
(exact geocoordinates) and `venueTimezone` are included for every event with a
resolved venue, along with `venueUrl`, a direct link to that venue's own SeatGeek
listing page (every upcoming event there).

**How do I know if an event was rescheduled?** The `isRescheduled` field is `true`
for events SeatGeek has flagged as moved from their original date; it is omitted
(not `false`) for events running as originally scheduled, consistent with this
actor's omit-empty-fields convention.

**Is a proxy required?** No. The actor uses a browser-matching HTTP client
signature by default and works reliably without any proxy. An optional Apify AUTO
(free datacenter) proxy is wired in and used automatically only if a request is
ever blocked.

### Limitations

- \*\*Individual event page links (`listingUrl` / `sourceUrl`) are real, correct
  SeatGeek URLs and open normally for a person in a real browser, but SeatGeek's
  bot-detection layer applies a stricter challenge to individual event-detail pages
  than to the category/performer/venue listing pages this actor reads — so these
  specific links are not reliably fetchable by any automated HTTP client (including
  this actor's own client) from a script or `curl`. This is the same class of caveat
  documented for other ticket-marketplace and real-estate actors in this catalog
  (e.g. valid-but-JS-gated detail pages) — the URL itself is correct, it just can't
  be re-scraped headlessly.
- **Per-event ticket counts, not a page-limited count.** SeatGeek server-renders a
  bounded set of currently-scheduled upcoming events per category/performer/venue
  (typically 10–75, more for broad categories like `concerts`); additional results
  load client-side via a "Show more" button that isn't part of the public page
  payload, so very large categories are capped at what the initial page includes.
- **No public full-text search API.** `search` mode resolves via SeatGeek's own
  SEO slug convention rather than a fuzzy search index — see the FAQ above.
- **Per-listing "Deal Score"** is not included — see the FAQ above for why.
- **US marketplace only.** This actor reads `seatgeek.com`. SeatGeek's separate
  country sites (e.g. `seatgeek.ca`) are not covered.

# Actor input Schema

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

What to scrape.

## `searchQuery` (type: `string`):

Name of an artist, sports team, or venue, e.g. `New York Yankees`, `Coldplay`, `Madison Square Garden`.

## `category` (type: `string`):

A SeatGeek event category — sports league, music genre, or entertainment type.

## `startUrls` (type: `array`):

Direct `seatgeek.com` URLs to fetch — category pages (`/nba-tickets`), performer pages (`/coldplay-tickets`), or venue pages (`/venues/madison-square-garden-tickets`).

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

Only include events on or after this date (`YYYY-MM-DD`). Applies to every mode.

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

Only include events on or before this date (`YYYY-MM-DD`). Applies to every mode.

## `minPrice` (type: `integer`):

Only include events whose lowest listed ticket price is at least this amount.

## `maxPrice` (type: `integer`):

Only include events whose lowest listed ticket price is at most this amount.

## `city` (type: `string`):

Only include events at a venue in this city, e.g. `Chicago`. Exact match, case-insensitive.

## `state` (type: `string`):

Only include events at a venue in this US state/province code, e.g. `IL`, `NY`, `CA`.

## `sortBy` (type: `string`):

How to order the emitted results.

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

Hard cap on emitted event records.

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

Optional. SeatGeek is protected by a bot-detection layer that blocks plain datacenter requests without a browser-matching TLS fingerprint; the actor already handles this in code with no proxy required. The free Apify AUTO proxy group is used automatically as a fallback only if a request is ever blocked.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "New York Yankees",
  "category": "nba",
  "startUrls": [
    {
      "url": "https://seatgeek.com/nfl-tickets"
    }
  ],
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset containing all scraped SeatGeek event listings.

# 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",
    "searchQuery": "New York Yankees",
    "category": "nba",
    "startUrls": [
        {
            "url": "https://seatgeek.com/nfl-tickets"
        }
    ],
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "search",
    "searchQuery": "New York Yankees",
    "category": "nba",
    "startUrls": [{ "url": "https://seatgeek.com/nfl-tickets" }],
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
  "searchQuery": "New York Yankees",
  "category": "nba",
  "startUrls": [
    {
      "url": "https://seatgeek.com/nfl-tickets"
    }
  ],
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/seatgeek-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/seatgeek-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeatGeek Scraper",
        "description": "Scrape SeatGeek - search live event listings by artist, team, or venue, or browse 156 sports/concert/theater categories. Get event date, venue, price range, and ticket counts.",
        "version": "1.0",
        "x-build-id": "rcAsWSF4jqa4F1sL4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~seatgeek-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-seatgeek-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~seatgeek-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-seatgeek-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~seatgeek-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-seatgeek-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Name of an artist, sports team, or venue, e.g. `New York Yankees`, `Coldplay`, `Madison Square Garden`.",
                        "default": "New York Yankees"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "af1",
                            "ahl",
                            "american-association",
                            "animal-sports",
                            "arizona-fall-league",
                            "atlantic-league",
                            "auto-racing",
                            "award-shows",
                            "ballet",
                            "banana-ball-championship-league",
                            "baseball",
                            "basketball",
                            "bchl",
                            "big3",
                            "boxing",
                            "broadway",
                            "cfl",
                            "champions-tour",
                            "circus",
                            "cirque-du-soleil",
                            "classical-music",
                            "climbing",
                            "comedy",
                            "concerts",
                            "convention",
                            "cricket",
                            "dance",
                            "double-a-baseball",
                            "drag-show",
                            "echl",
                            "entertainment",
                            "esports",
                            "european-soccer",
                            "extreme-sports",
                            "f1",
                            "family-entertainment",
                            "fighting",
                            "film",
                            "food-drink",
                            "football",
                            "fphl",
                            "frontier-league",
                            "golf",
                            "gymnastics",
                            "high-school-football",
                            "high-a-baseball",
                            "hockey",
                            "horse-racing",
                            "ifl",
                            "indycar",
                            "international-soccer",
                            "kijhl",
                            "korn-ferry-tour",
                            "lacrosse",
                            "literary-event",
                            "magic",
                            "masl",
                            "mens-professional-golf",
                            "minor-league-baseball",
                            "minor-league-hockey",
                            "mlb",
                            "mlb-partner-leagues",
                            "mlc",
                            "major-league-lacrosse",
                            "major-league-rugby",
                            "mls",
                            "mls-next",
                            "mls-next-pro",
                            "mma",
                            "monster-truck",
                            "motocross",
                            "music-festival",
                            "nahl",
                            "nal",
                            "nascar",
                            "nascar-cup-series",
                            "oreilly-auto-parts-series",
                            "nascar-truck-series",
                            "nba",
                            "nba-g-league",
                            "nbl",
                            "ncaa-baseball",
                            "college-esports",
                            "ncaa-football",
                            "college-gymnastics",
                            "ncaa-hockey",
                            "ncaa-basketball",
                            "college-golf",
                            "college-lacrosse",
                            "ncaa-soccer",
                            "college-volleyball",
                            "college-rodeo",
                            "college-softball",
                            "college-swimming",
                            "college-tennis",
                            "college-track-and-field",
                            "ncaa-womens-basketball",
                            "womens-college-golf",
                            "womens-college-hockey",
                            "womens-college-lacrosse",
                            "womens-college-soccer",
                            "womens-college-tennis",
                            "womens-college-volleyball",
                            "college-wrestling",
                            "nfl",
                            "nhl",
                            "nhra",
                            "nightlife",
                            "nisa",
                            "nll",
                            "nwsl",
                            "ohl",
                            "olympic-sports",
                            "opera",
                            "orchestra",
                            "pioneer-league",
                            "podcast",
                            "pwhl",
                            "qmjhl",
                            "rodeo",
                            "roller-derby",
                            "rugby",
                            "single-a-baseball",
                            "soccer",
                            "softball",
                            "speaker",
                            "sphl",
                            "sports",
                            "stadium-tours",
                            "super-league-soccer",
                            "swimming",
                            "the-arena-league",
                            "tennis",
                            "theater",
                            "track-and-field",
                            "triple-a-baseball",
                            "ufc",
                            "ufl",
                            "ushl",
                            "united-soccer-league",
                            "usl-championship",
                            "usl-league-one",
                            "usl-league-two",
                            "usl-w",
                            "vocal-performance",
                            "volleyball",
                            "whl",
                            "wnba",
                            "wnfc",
                            "womens-professional-golf",
                            "womens-professional-league-lacrosse",
                            "womens-flat-track-derby-association",
                            "world-cup",
                            "wrestling",
                            "wwe",
                            "x-league"
                        ],
                        "type": "string",
                        "description": "A SeatGeek event category — sports league, music genre, or entertainment type.",
                        "default": "nba"
                    },
                    "startUrls": {
                        "title": "SeatGeek URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct `seatgeek.com` URLs to fetch — category pages (`/nba-tickets`), performer pages (`/coldplay-tickets`), or venue pages (`/venues/madison-square-garden-tickets`).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Only include events on or after this date (`YYYY-MM-DD`). Applies to every mode."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Only include events on or before this date (`YYYY-MM-DD`). Applies to every mode."
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only include events whose lowest listed ticket price is at least this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only include events whose lowest listed ticket price is at most this amount."
                    },
                    "city": {
                        "title": "Venue city",
                        "type": "string",
                        "description": "Only include events at a venue in this city, e.g. `Chicago`. Exact match, case-insensitive."
                    },
                    "state": {
                        "title": "Venue state",
                        "type": "string",
                        "description": "Only include events at a venue in this US state/province code, e.g. `IL`, `NY`, `CA`."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date",
                            "priceLow",
                            "priceHigh",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "How to order the emitted results.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted event records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. SeatGeek is protected by a bot-detection layer that blocks plain datacenter requests without a browser-matching TLS fingerprint; the actor already handles this in code with no proxy required. The free Apify AUTO proxy group is used automatically as a fallback only if a request is ever blocked.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
