# Vividseats Tickets Listings Scraper (`stealth_mode/vividseats-tickets-listings-scraper`) Actor

Scrape ticket listings from Vivid Seats with complete listing details. This scraper extracts section, row, pricing, delivery methods, seat quality metrics, and 25+ fields per listing — perfect for price monitoring, market analysis, and secondary ticket market research.

- **URL**: https://apify.com/stealth\_mode/vividseats-tickets-listings-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

Learn more: https://docs.apify.com/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 Tickets Scraper: Extract Event Listing Data at Scale

---

### What Is Vivid Seats?

Vivid Seats is a leading secondary ticket marketplace where fans buy and sell tickets for concerts, sports events, theater shows, and live entertainment worldwide. The platform hosts millions of active listings with dynamic pricing, multiple delivery methods, and seller ratings. Extracting structured data from individual ticket listings manually is tedious and error-prone — the **Vivid Seats Tickets Scraper** automates this process, delivering complete listing intelligence instantly.

---

### Overview

The **Vivid Seats Tickets Scraper** extracts detailed ticket listing information from event pages on Vivid Seats, converting semi-structured web data into clean, queryable records. It captures pricing, seat location, fulfillment options, seller metrics, and quality indicators for every available listing.

**Ideal for:**

- **Price aggregators** building competitive ticket price databases
- **Market researchers** analyzing secondary ticket pricing trends
- **Resellers** monitoring inventory and pricing strategies
- **Event analysts** tracking ticket availability and demand patterns
- **Data scientists** studying ticket market dynamics

Key features include configurable item limits per URL, graceful error handling, and comprehensive field coverage spanning seat details, pricing, delivery methods, and seller trust metrics.

---

### Input Format

The scraper accepts a JSON configuration object defining which listings to collect:

```json
{
  "urls": [
    "https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | array | Event page URLs from Vivid Seats to scrape. Paste individual listing URLs where tickets are displayed. |
| `max_items_per_url` | integer | Maximum number of ticket listings to extract per URL (e.g., `200`). Higher values collect more seat options; lower values speed up runs. |
| `ignore_url_failures` | boolean | If `true`, the scraper continues processing remaining URLs even if some fail. Useful for bulk runs. |

> **Tip:** Use specific event URLs, not search results pages, for best results. Each URL should display available ticket listings.

***

### Output Format

**Sample output**

```json
{
  "section": "303",
  "row": "22",
  "quantity": "2",
  "price_per_ticket": "1183.00",
  "deal_score": "5.5",
  "listing_id": "VB15853444331",
  "internal_code": "408120",
  "delivery_method": "Ticketmaster Transfer",
  "note": "Please note that you will need to use an iOS or Android mobile device to gain entry to your event.",
  "fulfillment_type": "0",
  "status": "1",
  "is_guaranteed": "0",
  "is_transferred": "0",
  "mobile_required": "2",
  "is_individual_seats": "0",
  "is_instant_electronic_transfer": "0",
  "is_instant_flash_seats": "0",
  "is_sold": "0",
  "low_seat": "19",
  "high_seat": "20",
  "has_discount": false,
  "fulfillment_discount_info": "",
  "price_discount_info": "",
  "badges": [
    {
      "category": "PRICE",
      "title": "Lowest Price in Section"
    }
  ],
  "perks": [
    "Seated Together"
  ],
  "local_prices": null,
  "from_url": "https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"
}
```

Each scraped ticket listing returns 25+ fields providing complete seat and pricing information:

#### Seat Location & Identification

| Field | Meaning |
|---|---|
| `Section` | Stadium/venue section where the seats are located (e.g., "Upper Level 200") |
| `Row` | Row number within the section |
| `Low Seat` | Lowest seat number in the listing block |
| `High Seat` | Highest seat number in the listing block |
| `Quantity` | Number of adjacent seats available in this listing |
| `Is Individual Seats` | Whether the listing includes non-contiguous seat groups |

#### Pricing & Deal Metrics

| Field | Meaning |
|---|---|
| `Price Per Ticket` | Unit price per ticket (not including fees) |
| `Deal Score` | Vivid Seats' proprietary score indicating listing quality/value (higher = better deal) |
| `Has Discount` | Whether the listing includes a seller discount |
| `Price Discount Info` | Details about any price discounts applied |
| `Fulfillment Discount Info` | Discounts related to delivery method selection |
| `Local Prices` | Prices adjusted for the buyer's local currency or region |

#### Fulfillment & Delivery

| Field | Meaning |
|---|---|
| `Delivery Method` | How tickets are delivered (e.g., electronic transfer, physical mail, mobile delivery) |
| `Fulfillment Type` | Category of delivery (e.g., guaranteed, instant, standard) |
| `Is Guaranteed` | Whether the seller guarantees ticket authenticity and arrival by event date |
| `Is Instant Electronic Transfer` | Whether tickets transfer instantly via email |
| `Is Instant Flash Seats` | Whether tickets use Vivid Seats' Flash Seats mobile delivery system |
| `Mobile Required` | Whether a mobile device is required to access the tickets |

#### Listing Status & Availability

| Field | Meaning |
|---|---|
| `Listing ID` | Unique identifier for this specific ticket listing |
| `Internal Code` | Internal Vivid Seats reference code for tracking |
| `Status` | Current listing state (e.g., active, sold, pending) |
| `Is Sold` | Whether the listing has been sold (`true`/`false`) |
| `Is Transferred` | Whether tickets have already been transferred to the buyer |

#### Seller Trust & Attributes

| Field | Meaning |
|---|---|
| `Badges` | Trust badges or certifications the seller has earned (e.g., "Top Seller," "Verified") |
| `Perks` | Special offers or benefits tied to the listing (e.g., "Fan Protect Guarantee") |
| `Note` | Any additional notes or warnings from the seller (e.g., "Will call pickup required") |

***

### How to Use

1. **Locate event pages** — Navigate to Vivid Seats, search for your event (e.g., "World Cup 2026"), and open the event page showing available listings.
2. **Copy the URL** — Copy the full event URL from your browser. It typically contains the event name and a production ID.
3. **Configure settings** — Paste the URL(s) into the `urls` array. Set `max_items_per_url` to match your data needs (e.g., `200` for comprehensive market data).
4. **Enable error handling** — Set `ignore_url_failures: true` for bulk runs to handle network issues gracefully.
5. **Run the scraper** — Start the actor and monitor progress via the live log.
6. **Export & analyze** — Download results as JSON, CSV, or Excel for analysis in spreadsheets or databases.

**Best practices:**

- Use event URLs (not search results) for consistent, complete data.
- Set reasonable `max_items_per_url` limits to balance coverage vs. runtime.
- Run multiple URLs in a single execution to batch-process multiple events.
- Check output sample before scaling to verify URL compatibility.

***

### Use Cases & Business Value

- **Price monitoring dashboards** — Track Vivid Seats pricing trends for specific events over time
- **Competitive intelligence** — Compare your ticket inventory against competitor offerings
- **Market research reports** — Analyze deal scores, delivery methods, and seller strategies across thousands of listings
- **Algorithmic reselling** — Automate data collection for dynamic repricing strategies
- **Event demand analysis** — Identify sold-out sections and peak pricing periods

The scraper transforms Vivid Seats' web interface into actionable data, enabling data-driven decisions in the secondary ticket market.

***

### Conclusion

The **Vivid Seats Tickets Scraper** extracts complete listing intelligence from Vivid Seats, covering seat locations, pricing, delivery methods, and seller metrics across 25+ fields. Whether you're a price analyst, market researcher, or data-driven reseller, this scraper saves hours of manual work and delivers the structured data you need. Start scraping event listings today and unlock market insights instantly.

# Actor input Schema

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

Add the URLs of the tickets listings urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/vividseats-tickets-listings-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 = {
    "urls": ["https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/vividseats-tickets-listings-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 '{
  "urls": [
    "https://www.vividseats.com/world-cup-soccer-tickets-metlife-stadium-6-13-2026--sports-soccer/production/5080443?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/vividseats-tickets-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vividseats Tickets Listings Scraper",
        "description": "Scrape ticket listings from Vivid Seats with complete listing details. This scraper extracts section, row, pricing, delivery methods, seat quality metrics, and 25+ fields per listing — perfect for price monitoring, market analysis, and secondary ticket market research.",
        "version": "0.0",
        "x-build-id": "AHgm9SSjMuoQ6nfXN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~vividseats-tickets-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-vividseats-tickets-listings-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/stealth_mode~vividseats-tickets-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-vividseats-tickets-listings-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/stealth_mode~vividseats-tickets-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-vividseats-tickets-listings-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",
                "properties": {
                    "urls": {
                        "title": "URLs of the tickets listings urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the tickets listings urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
