# Vivid Seats Scraper (`parsebird/vividseats-scraper`) Actor

Scrape Vivid Seats events from search, performer, venue and event URLs: ticket prices (min, max, average, median, all-in), listing and ticket counts, dates, venue, performers and top deals. Export JSON, CSV, Excel.

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

## Pricing

from $1.49 / 1,000 events

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### Vivid Seats Scraper

Vivid Seats Scraper pulls event and ticket price data from [Vivid Seats](https://www.vividseats.com) for concerts, sports, theater and comedy. It returns min, max, average, median and all-in prices, listing and ticket counts, dates, venues and performers for every event.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">Paste any Vivid Seats search, performer, team, venue or event URL, or just type a keyword, to get 30+ fields per event, including the top 5 ticket deals with section, row, price and deal score.</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/vividseats-scraper — scrapes Vivid Seats (vividseats.com) events with ticket price statistics. Call: ApifyClient("TOKEN").actor("parsebird/vividseats-scraper").call(run_input={"startUrls": [{"url": "https://www.vividseats.com/search?searchTerm=imagine"}, {"url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973"}], "searchTerms": ["knicks"], "maxItems": 50, "scrapeEventDetails": true}). Inputs: startUrls (array of {url}; Vivid Seats search, performer/team, venue or event /production/ URLs), searchTerms (array of strings, optional keyword searches), maxItems (int, default 100, max events across all inputs), scrapeEventDetails (bool, default false; adds topDeals, topDealsLowestPrice, onsaleDate, presale1Date, presale2Date, imageUrl by opening each event page), includeParking (bool, default false; also save parking-pass listings), proxyConfiguration (optional Apify Proxy). At least one startUrl or searchTerm is required. Output: one dataset item per event with eventId, eventName, url, localDateTime, timezone, utcDateTime, dateTbd, timeTbd, venueName, venueCity, venueState, venueCountry, category, subCategory, primaryPerformer, minPrice, maxPrice, avgPrice, medianPrice, minAllInPrice, maxAllInPrice, currency, listingCount, ticketCount, onsaleDate, presale1Date, presale2Date, delayStatus, ifNecessary, lastPricingRefresh, topDealsLowestPrice, topDeals[{section,row,price,dealScore}], venue{id,name,address1,city,state,postalCode,countryCode,latitude,longitude,url}, performers[{id,name,url,category,subCategory,isPrimary}], seatingChartUrl, imageUrl, sourceUrl, scrapedAt. Pricing: pay per event saved. API docs: https://docs.apify.com/api/v2  Token: https://console.apify.com/settings/integrations
```

### What is Vivid Seats Scraper?

**Vivid Seats Scraper** is a Vivid Seats API alternative. It collects **event listings and ticket price statistics** from vividseats.com, one of the largest ticket resale marketplaces in the US. Give it a search, a team or artist page, a venue or a single event, and it returns **clean, structured event data**. You don't need a Vivid Seats account or a browser.

The easiest way to try it: open the **Input** tab, keep the prefilled search and venue URLs, and click **Start**. You'll have 10 events in your dataset in under a minute.

### What can Vivid Seats Scraper do?

- 🔎 **Search Vivid Seats** by keyword, the same way as the site's search box, or paste a `/search?searchTerm=` URL
- 🎤 **Scrape performer and team pages**, e.g. every upcoming New York Knicks game or a band's tour dates
- 🏟️ **Scrape venue pages**, e.g. the full event calendar of Madison Square Garden (up to 600 events per venue)
- 🎟️ **Scrape single event pages** (`/production/...` URLs) for one event's prices
- 💲 **Ticket price stats** for every event: min, max, average and median listing price, plus min and max **all-in price** (fees included)
- 📊 **Supply signals**: number of listings and number of tickets for sale
- 🏷️ **Top deals** (optional): the 5 best-value listings shown on the event page, with section, row, price and Vivid Seats deal score
- ♻️ **Deduplication**: an event found through several URLs is saved once
- 🅿️ **Clean results**: Vivid Seats' separate parking-pass listings are skipped unless you turn them on

On the Apify platform you also get:

- ⏰ [Scheduling](https://docs.apify.com/platform/schedules), to track ticket prices daily or hourly
- 🔌 [API access](https://docs.apify.com/api/v2) and [integrations](https://apify.com/integrations) with Google Sheets, Zapier, Make, Slack, webhooks and more
- 📁 Export to **JSON, CSV, Excel, XML or HTML**

### What data can you extract from Vivid Seats?

| Field | Description |
|-------|-------------|
| `eventName` | Event title, e.g. "Brooklyn Nets at New York Knicks" |
| `url` | Event page on Vivid Seats |
| `localDateTime` / `utcDateTime` | Event start time, local (with offset) and UTC |
| `venueName`, `venueCity`, `venueState` | Where the event takes place (full address and coordinates in `venue`) |
| `category`, `subCategory` | e.g. Sports / NBA Basketball, Concerts / Rock |
| `primaryPerformer`, `performers` | Headliner and all performers or teams, with their Vivid Seats pages |
| `minPrice`, `maxPrice`, `avgPrice`, `medianPrice` | Listing price statistics across all tickets for sale |
| `minAllInPrice`, `maxAllInPrice` | Lowest and highest price including fees |
| `listingCount`, `ticketCount` | Number of listings and tickets currently for sale |
| `topDeals` | Up to 5 top deals: section, row, price, deal score (event details mode) |
| `onsaleDate`, `presale1Date`, `presale2Date` | General on-sale and presale dates, when published (event details mode) |
| `seatingChartUrl`, `imageUrl` | Venue seating chart image and event image |

### How to scrape Vivid Seats

1. Open [Vivid Seats Scraper](https://apify.com/parsebird/vividseats-scraper) in Apify Console and go to the **Input** tab.
2. Paste one or more Vivid Seats URLs into **Start URLs**: a search, a performer or team, a venue, or an event page. You can also type keywords into **Search terms**.
3. Set **Max events** to the number of events you need.
4. Turn on **Scrape event details** if you want top deals, on-sale dates and event images.
5. Click **Start** and wait for the run to finish.
6. Download your Vivid Seats data from the **Output** tab as JSON, CSV or Excel, or fetch it via the API.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | array | One of these two | — | Vivid Seats URLs: search (`/search?searchTerm=...`), performer/team (`/performer/...`), venue (`/venue/...`) or event (`/production/...`) |
| `searchTerms` | array of strings | One of these two | — | Keywords to search on Vivid Seats, e.g. `taylor swift`, `knicks` |
| `maxItems` | integer | No | 100 | Maximum number of events to save across all inputs |
| `scrapeEventDetails` | boolean | No | false | Open each event page to add top deals, on-sale/presale dates and the event image |
| `includeParking` | boolean | No | false | Also save parking passes, which Vivid Seats lists as separate events |
| `proxyConfiguration` | object | No | no proxy | Optional Apify Proxy settings |

Example input:

```json
{
    "startUrls": [
        { "url": "https://www.vividseats.com/search?searchTerm=imagine" },
        { "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973" }
    ],
    "searchTerms": ["knicks"],
    "maxItems": 50,
    "scrapeEventDetails": true
}
```

### Output example

Each event is one dataset item. This is a real record (shortened `performers`) scraped with **Scrape event details** on:

```json
{
  "eventId": 7432933,
  "eventName": "Brooklyn Nets at New York Knicks",
  "url": "https://www.vividseats.com/new-york-knicks-tickets-madison-square-garden-11-2-2026/production/7432933",
  "localDateTime": "2026-11-02T19:30:00-05:00",
  "timezone": "America/New_York",
  "utcDateTime": "2026-11-03T00:30:00Z",
  "dateTbd": false,
  "timeTbd": false,
  "venueName": "Madison Square Garden",
  "venueCity": "New York",
  "venueState": "NY",
  "venueCountry": "US",
  "category": "Sports",
  "subCategory": "NBA Basketball",
  "primaryPerformer": "New York Knicks",
  "minPrice": 124.8,
  "maxPrice": 9700,
  "avgPrice": 512.23,
  "medianPrice": 300,
  "minAllInPrice": 168,
  "maxAllInPrice": 13094,
  "currency": "USD",
  "listingCount": 1055,
  "ticketCount": 3095,
  "onsaleDate": "2026-09-16T12:00:00-05:00",
  "presale1Date": "2026-09-14T10:00:00-05:00",
  "presale2Date": "2026-09-15T10:00:00-05:00",
  "delayStatus": "NONE",
  "ifNecessary": false,
  "lastPricingRefresh": "2026-10-29T07:09:52-05:00",
  "topDealsLowestPrice": 176.0,
  "topDeals": [
    { "section": "Section 208", "row": "7", "price": 227.0, "dealScore": 10 },
    { "section": "Section 209", "row": "8", "price": 229.0, "dealScore": 10 },
    { "section": "Section 226", "row": "4", "price": 239.0, "dealScore": 10 }
  ],
  "venue": {
    "id": 973,
    "name": "Madison Square Garden",
    "address1": "4 Pennsylvania Plaza",
    "address2": null,
    "city": "New York",
    "state": "NY",
    "postalCode": "10001",
    "countryCode": "US",
    "timezone": "America/New_York",
    "latitude": 40.7505045,
    "longitude": -73.9934387,
    "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973"
  },
  "performers": [
    {
      "id": 602,
      "name": "New York Knicks",
      "url": "https://www.vividseats.com/new-york-knicks-tickets--sports-nba-basketball/performer/602",
      "category": "Sports",
      "subCategory": "NBA Basketball",
      "isPrimary": true
    }
  ],
  "seatingChartUrl": "https://d2o50i5c2dr30a.cloudfront.net/091a6d56-50a6-494b-9058-d4557dbc60a3.png",
  "imageUrl": "https://a.vsstatic.com/mobile/app/nba/new-york-knicks-3.jpg",
  "sourceUrl": "https://www.vividseats.com/madison-square-garden-tickets/venue/973",
  "scrapedAt": "2026-10-29T12:32:42+00:00"
}
```

Without **Scrape event details**, `topDeals`, `topDealsLowestPrice` and `imageUrl` are `null`. On-sale dates are still filled for events found on venue pages, because Vivid Seats includes them there.

### Use cases

- **Ticket price tracking**: schedule daily runs and watch how min, median and all-in prices move as an event gets closer
- **Resale market research**: compare listing and ticket counts across teams, tours, venues and cities
- **Event discovery**: build a calendar of upcoming concerts, games and shows for a venue or city
- **Arbitrage and pricing**: spot events where the median price is far above the minimum, or where supply is thin
- **Price comparison**: combine with our [StubHub Event Scraper](https://apify.com/parsebird/stubhub-event-scraper) and [TickPick Events Scraper](https://apify.com/parsebird/tickpick-events-scraper) to compare marketplaces

### How it works

1. Each start URL is opened and the event data embedded in the Vivid Seats page is read. No browser is needed.
2. A search page lists its first 25 events. Performer pages list the performer's upcoming events (only the first 25 for performers with very many dates). Venue pages list up to 600.
3. When a search needs more than its first 25 results, the scraper continues through performer and venue pages whose names match every word of the search term.
4. With **Scrape event details** on, each event page is opened as well, five at a time, to add top deals and on-sale dates.
5. Parking passes are skipped unless **Include parking passes** is on. Events are deduplicated by ID, saved to the dataset as they're found, and the run stops at **Max events** or at your spending limit.

### How much does it cost to scrape Vivid Seats?

Vivid Seats Scraper uses **pay-per-event** pricing. You pay for each event saved to the dataset, and nothing else: platform compute and proxy usage are included in the event price.

| Event | Free plan | Bronze | Silver | Gold |
|-------|-----------|--------|--------|------|
| `event` (per event saved) | $0.00299 | $0.00249 | $0.00199 | $0.00149 |
| Per 1,000 events | **$2.99** | **$2.49** | **$1.99** | **$1.49** |

For example, the full 150-event calendar of Madison Square Garden costs about $0.45 on the Free plan. Turning on **Scrape event details** doesn't change the price per event. Apify's Free plan includes monthly platform credits you can spend on this actor.

### Using the Vivid Seats Scraper API

You can run Vivid Seats Scraper from your own code with the [Apify API](https://docs.apify.com/api/v2) and fetch results as JSON.

**Python** ([apify-client](https://docs.apify.com/api/client/python)):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/vividseats-scraper").call(run_input={
    "searchTerms": ["knicks"],
    "maxItems": 50,
    "scrapeEventDetails": True,
})

for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["eventName"], event["localDateTime"], event["minPrice"], event["medianPrice"])
```

**JavaScript** ([apify-client](https://docs.apify.com/api/client/js)):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/vividseats-scraper').call({
    startUrls: [{ url: 'https://www.vividseats.com/madison-square-garden-tickets/venue/973' }],
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((e) => console.log(e.eventName, e.localDateTime, e.minAllInPrice));
```

### FAQ

**Which Vivid Seats URLs are supported?**
Search pages (`/search?searchTerm=...`), performer and team pages (`.../performer/<id>`), venue pages (`.../venue/<id>`) and event pages (`.../production/<id>`). Category pages such as `/concerts` also work when Vivid Seats shows an event list on them.

**Does it return every individual ticket listing for an event?**
No. Each record holds the event's price statistics (min, max, average, median, all-in) and listing and ticket counts. With **Scrape event details** on, you also get the top 5 deals shown on the event page. Seat-by-seat listing data isn't included.

**Why did my event URL return nothing?**
Vivid Seats removes past events, and their URLs redirect to the performer page. The run log flags these URLs and skips them. Pass the performer or venue URL to get that act's current events.

**How many events can I get from one search?**
A Vivid Seats search page lists its first 25 events. The scraper then continues through matching performer and venue pages. Searching for an exact artist, team or venue name gives the most complete results. Some exact-name searches redirect straight to the performer or venue page, and that works too.

**Why are parking passes missing?**
Vivid Seats sells parking for many events as separate listings, which would crowd out real events. They're skipped by default. Turn on **Include parking passes** to keep them.

**What currency are prices in?**
The currency is in the `currency` field. Runs on Apify return USD prices.

**Do I need a proxy?**
Usually not. Vivid Seats pages loaded without a proxy in our tests. If you see repeated errors in the log, enable Apify Proxy under **Advanced**.

**Can I monitor prices over time?**
Yes. Create a [schedule](https://docs.apify.com/platform/schedules) for the same input and compare `minPrice`, `medianPrice` and `ticketCount` between runs. Each record has a `scrapedAt` timestamp.

**Can I connect it to Google Sheets, Zapier or Make?**
Yes. Use Apify [integrations](https://apify.com/integrations) or a webhook to send each finished run's dataset wherever you need it.

**Something isn't working. What should I do?**
Open an issue in the **Issues** tab with your input and run link. We read every report.

### Is it legal to scrape Vivid Seats?

Vivid Seats Scraper collects only publicly available event and price information that anyone can see on vividseats.com without logging in. It doesn't collect personal data. Still, you should review Vivid Seats' terms of use and the laws that apply to you, such as GDPR or CCPA, before using scraped data. If you're unsure, ask a lawyer. For background, read Apify's blog post [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Related Actors

- [StubHub Event Scraper](https://apify.com/parsebird/stubhub-event-scraper): StubHub events by city or explore URL
- [TickPick Events Scraper](https://apify.com/parsebird/tickpick-events-scraper): TickPick events and prices
- [Dice.fm Events Scraper](https://apify.com/parsebird/dice-fm-events-scraper): Dice.fm events and ticket types
- [Resident Advisor Scraper](https://apify.com/parsebird/resident-advisor-scraper): electronic music events from Resident Advisor
- [Luma Events Scraper](https://apify.com/parsebird/luma-events-scraper): events from Luma
- [Meetup Events Scraper](https://apify.com/parsebird/meetup-events-scraper): Meetup events, groups and RSVPs

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/vividseats-scraper/changelog.md

# Actor input Schema

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

Add Vivid Seats URLs. Supported: search pages (<code>/search?searchTerm=...</code>), performer or team pages (<code>/performer/...</code>), venue pages (<code>/venue/...</code>) and event pages (<code>/production/...</code>).

## `searchTerms` (type: `array`):

Enter artists, teams, shows or venues to search on Vivid Seats. Each term runs the same search as the site's search box.

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

Maximum number of events to save across all URLs and search terms.

## `scrapeEventDetails` (type: `boolean`):

Open each event page to add the top 5 ticket deals (section, row, price, deal score), the lowest deal price, on-sale and presale dates, and the event image. Adds one page load per event.

## `includeParking` (type: `boolean`):

Save parking passes too. Vivid Seats sells parking for many events as separate listings; they're skipped by default.

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

Optional. Vivid Seats pages load without a proxy in most cases; enable Apify Proxy if you see repeated errors.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vividseats.com/search?searchTerm=imagine"
    },
    {
      "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973"
    }
  ],
  "maxItems": 10,
  "scrapeEventDetails": true,
  "includeParking": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.vividseats.com/search?searchTerm=imagine"
        },
        {
            "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973"
        }
    ],
    "maxItems": 10,
    "scrapeEventDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "startUrls": [
        { "url": "https://www.vividseats.com/search?searchTerm=imagine" },
        { "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973" },
    ],
    "maxItems": 10,
    "scrapeEventDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/vividseats-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 '{
  "startUrls": [
    {
      "url": "https://www.vividseats.com/search?searchTerm=imagine"
    },
    {
      "url": "https://www.vividseats.com/madison-square-garden-tickets/venue/973"
    }
  ],
  "maxItems": 10,
  "scrapeEventDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parsebird/vividseats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/vividseats-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/c1ZS3vU4GbefFcYj8/builds/dn25eSu2HYaOAIqpV/openapi.json
