# Vivid Seats Ticket Marketplace Scraper (`crawlerbros/vividseats-scraper`) Actor

Scrape live event listings from Vivid Seats - concerts, sports, and theater tickets. Browse by performer/team/venue name, by city, or by category, with date range filtering and real-time "from $X" price data.

- **URL**: https://apify.com/crawlerbros/vividseats-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Agents
- **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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Vivid Seats Scraper

Scrape **Vivid Seats** — a major US ticket resale marketplace for concerts, sports, and theater. Browse events by performer, team, or venue name, by city, or by category, with date-range filtering and live "from $X" pricing. No login, no API key, no residential proxy required.

### What this actor does

- **Three modes:** `byCategory` (concerts / sports / theater / all), `search` (performer, team, or venue name), `byCity` (any US city or region Vivid Seats recognizes)
- **Date range filter** works across every mode
- **Live pricing:** minimum, maximum, average, and median ticket price per event, plus active listing and ticket counts
- **Full venue detail:** name, city, state, country, coordinates, and venue page URL
- **Empty fields are omitted** — every record only contains fields that were actually available

### Output per event

- `eventId` — Vivid Seats internal event ID
- `name` — event title
- `localDate` — event start date/time in the venue's local timezone (ISO 8601)
- `eventDate` — event date (`YYYY-MM-DD`), used for date-range filtering
- `utcDate` — event start in UTC
- `dateTbd`, `timeTbd` — true if the date/time is not yet confirmed
- `venueName`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`
- `venueUrl` — Vivid Seats venue page
- `venueLatitude`, `venueLongitude`
- `venueCapacity` — venue seating capacity, when published
- `category` — `Concerts` / `Sports` / `Theater`
- `subCategory` — finer genre/league, e.g. `Pop`, `Country and Folk`, `PGA Golf`
- `performers[]` — every performer/team/artist billed on the event
- `minPrice`, `maxPrice`, `avgPrice`, `medianPrice` — ticket price range (USD)
- `listingCount`, `ticketCount` — active resale inventory
- `onsaleDate` — public on-sale date, if known
- `presaleDate` — earliest presale date, if known
- `eventUrl` — Vivid Seats event/ticket page
- `recordType: "event"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `byCategory` / `search` / `byCity` |
| `searchQuery` | string | `New York Yankees` | Performer, team, or venue name (mode=search) |
| `cityQuery` | string | `Austin` | US city or region name (mode=byCity) |
| `category` | string | `concerts` | `concerts` / `sports` / `theater` / `all` (mode=byCategory) |
| `dateFrom` | string | – | Only events on/after this date (`YYYY-MM-DD`), all modes |
| `dateTo` | string | – | Only events on/before this date (`YYYY-MM-DD`), all modes |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |
| `proxyConfiguration` | object | AUTO | Optional Apify proxy; not required |

#### Example: browse concerts

```json
{
  "mode": "byCategory",
  "category": "concerts",
  "maxItems": 50
}
````

#### Example: browse sports in a date range

```json
{
  "mode": "byCategory",
  "category": "sports",
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "maxItems": 100
}
```

#### Example: search by team

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

#### Example: browse by city

```json
{
  "mode": "byCity",
  "cityQuery": "Las Vegas",
  "maxItems": 50
}
```

### Use cases

- **Ticket price tracking** — monitor "from $X" prices over time for an artist, team, or venue
- **Event calendars** — build a local events feed for a city or region
- **Market research** — compare listing counts and price ranges across venues or categories
- **Fan tools** — alert on new upcoming shows for a favorite performer or team
- **Venue analytics** — track upcoming event volume at a specific venue

### Data Source / Limitations

Data comes from Vivid Seats' public website (vividseats.com) — no login or account is required to view listings. `search` and `byCity` resolve a free-text name through Vivid Seats' own site search; if a query is ambiguous or has no exact match (e.g. it matches multiple artists, or isn't a recognized US city/region), the actor returns 0 records with a clear status message instead of guessing. Vivid Seats only lists **upcoming** events — a `dateTo` in the past will always return 0 records, since past events are never listed.

### FAQ

**Is this affiliated with Vivid Seats?**
No. This is an independent, third-party actor that reads Vivid Seats' public website. It is not affiliated with, endorsed by, or sponsored by Vivid Seats.

**Why does `search` sometimes return 0 records for a name I know is on Vivid Seats?**
Two reasons: (1) the performer/team/venue has no upcoming events listed right now — ticket marketplaces only carry future events, so an artist between tours will show 0; (2) the name didn't resolve to a single Vivid Seats page (too ambiguous, or a typo). Try the exact name as it appears on vividseats.com.

**Why does `byCity` fail for some well-known city names?**
A handful of city names collide with performer or band names on Vivid Seats' own search (e.g. a city that shares its name with a touring act), so the site can't uniquely resolve them to a location. Try a more specific or alternate spelling of the city.

**Do I need a proxy?**
No. The actor works reliably without any proxy configuration. An optional Apify AUTO (datacenter) proxy can be enabled for extra IP diversity, but it is not required and no paid/residential proxy is ever needed.

**How fresh is the pricing data?**
Prices reflect live resale marketplace listings at the time the actor runs — they change frequently as tickets are bought and sold.

**Are prices in USD?**
Yes, all price fields are in US dollars.

**Can I filter by date range and category/performer/city at the same time?**
Yes — `dateFrom`/`dateTo` apply on top of whichever mode you choose.

**What happens if I request more items than exist?**
The actor returns as many real records as exist (up to `maxItems`) and stops — it never fabricates placeholder records.

# Actor input Schema

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

What to browse.

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

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

## `cityQuery` (type: `string`):

A US city or region name, e.g. `Chicago`, `Austin`, `Las Vegas`, `New York`.

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

Vivid Seats' top-level event category.

## `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.

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

Hard cap on emitted event records.

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

Optional. Vivid Seats 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. The free Apify AUTO proxy group can be enabled for extra IP diversity, but is not required.

## Actor input object example

```json
{
  "mode": "byCategory",
  "searchQuery": "New York Yankees",
  "cityQuery": "Austin",
  "category": "concerts",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Vivid Seats 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": "byCategory",
    "searchQuery": "New York Yankees",
    "cityQuery": "Austin",
    "category": "concerts",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vividseats-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": "byCategory",
    "searchQuery": "New York Yankees",
    "cityQuery": "Austin",
    "category": "concerts",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vividseats-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": "byCategory",
  "searchQuery": "New York Yankees",
  "cityQuery": "Austin",
  "category": "concerts",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/vividseats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vivid Seats Ticket Marketplace Scraper",
        "description": "Scrape live event listings from Vivid Seats - concerts, sports, and theater tickets. Browse by performer/team/venue name, by city, or by category, with date range filtering and real-time \"from $X\" price data.",
        "version": "1.0",
        "x-build-id": "YoEF1S9ClFRTCFdaa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~vividseats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-vividseats-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~vividseats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-vividseats-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~vividseats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-vividseats-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": [
                            "byCategory",
                            "search",
                            "byCity"
                        ],
                        "type": "string",
                        "description": "What to browse.",
                        "default": "byCategory"
                    },
                    "searchQuery": {
                        "title": "Performer, team, or venue name (mode=search)",
                        "type": "string",
                        "description": "Name of an artist, sports team, or venue, e.g. `Taylor Swift`, `New York Yankees`, `Madison Square Garden`.",
                        "default": "New York Yankees"
                    },
                    "cityQuery": {
                        "title": "City (mode=byCity)",
                        "type": "string",
                        "description": "A US city or region name, e.g. `Chicago`, `Austin`, `Las Vegas`, `New York`.",
                        "default": "Austin"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "concerts",
                            "sports",
                            "theater",
                            "all"
                        ],
                        "type": "string",
                        "description": "Vivid Seats' top-level event category.",
                        "default": "concerts"
                    },
                    "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."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted event records.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Vivid Seats 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. The free Apify AUTO proxy group can be enabled for extra IP diversity, but is not required.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```