# Vivid Seats Events & Ticket Listings Scraper (`automation-lab/vivid-seats-events-tickets-scraper`) Actor

🎟️ Extract public Vivid Seats event schedules and live ticket inventory with venue details, prices, sections, rows, quantities, deal scores, perks, and snapshot timestamps.

- **URL**: https://apify.com/automation-lab/vivid-seats-events-tickets-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## Vivid Seats Events & Ticket Listings Scraper

Extract public Vivid Seats event schedules and live resale-ticket inventory into clean, typed datasets.

Use performer pages, search/category pages, event URLs, or production IDs to collect:

- 🎟️ event names, dates, categories, and performers
- 📍 venue names, addresses, coordinates, time zones, and capacities
- 📊 listing counts, ticket counts, and price summaries
- 💺 sections, rows, available quantities, and listing IDs
- 💵 base, all-in, and localized ticket prices
- ⭐ deal scores, badges, perks, and delivery notes

The Actor uses an anonymous browser session to clear Vivid Seats' JavaScript challenge, then queries the public data calls used by the website. No Vivid Seats login or API key is required.

### What does this Vivid Seats scraper do?

The scraper turns current Vivid Seats event and ticket inventory into structured JSON.

It supports two related workflows:

1. Discover events attached to a performer, team, tournament, search, or category page.
2. Snapshot the live ticket listings attached to selected production IDs.

Events and listings are saved separately, so analysts can join them by `productionId` without mixing different record shapes.

### Who is it for?

#### Ticket brokers

Monitor price, quantity, section, and row changes for selected events.

#### Resale-pricing teams

Build time-series snapshots of minimum prices, deal scores, and inventory depth.

#### Event discovery products

Import upcoming dates, venues, performers, and source URLs into calendars or catalogs.

#### Market analysts

Compare supply and price distributions across events, venues, categories, and dates.

#### Data engineers

Schedule a stable extraction job and send the named datasets to a warehouse or dashboard.

### Why use this Actor?

- ✅ No Vivid Seats account or private API credential
- ✅ Event discovery and listing extraction in one run
- ✅ Stable normalized numeric fields instead of opaque website keys
- ✅ Separate Events and Ticket Listings datasets
- ✅ Direct production-ID mode for repeated snapshots
- ✅ Optional currencies and Apify Proxy sessions
- ✅ Configurable limits for predictable run size
- ✅ Fail-closed validation for unsupported URLs and empty extraction

### Supported Vivid Seats inputs

Use one or more of these inputs:

- Performer URL, such as a team, artist, or tournament page
- Event URL containing `/production/<id>`
- Search or category URL that displays links to event productions
- Numeric production ID copied from a Vivid Seats event URL

All URLs must use the `vividseats.com` domain.

At least one URL or production ID is required.

### Quick start

1. Open the Actor input page.
2. Paste a Vivid Seats performer or event URL.
3. Keep `includeListings` enabled for ticket-level output.
4. Choose low event and listing limits for the first run.
5. Select a currency.
6. Click **Start**.
7. Open the Events and Ticket Listings datasets.

Example event-discovery input:

```json
{
  "startUrls": [
    {
      "url": "https://www.vividseats.com/big-12-mens-basketball-tournament-tickets--sports-ncaa-basketball/performer/81"
    }
  ],
  "includeListings": false,
  "maxEvents": 10,
  "currency": "USD"
}
````

### Input reference

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | sample performer | Vivid Seats performer, search/category, or production URLs |
| `productionIds` | array | `[]` | Direct production IDs for inventory snapshots |
| `includeListings` | boolean | `true` | Save listing-level ticket records |
| `maxEvents` | integer | `10` | Maximum event records across inputs |
| `maxListingsPerEvent` | integer | `20` | Maximum ticket listings for each event |
| `currency` | string | `USD` | USD, CAD, EUR, GBP, or AUD |
| `navigationTimeoutSecs` | integer | `45` | Browser navigation timeout |
| `proxyConfiguration` | object | none | Optional Apify Proxy settings |

Keep limits low when validating a new target or proxy configuration.

### Output datasets

The Actor declares two named datasets.

#### Events

One row per Vivid Seats production.

#### Ticket Listings

One row per current ticket listing.

This design makes CSV exports and database imports easier than a mixed dataset with a `recordType` discriminator.

Both datasets can be joined with `productionId`.

### Event data fields

| Field | Meaning |
|---|---|
| `productionId` | Stable Vivid Seats event/production ID |
| `name` | Event name |
| `localDate` | Event date in venue time zone |
| `utcDate` | Event date in UTC |
| `category` | Main event category |
| `subcategory` | More specific category |
| `venue` | Venue identity, location, coordinates, time zone, and capacity |
| `minPrice` | Lowest current base price |
| `maxPrice` | Highest current base price |
| `averagePrice` | Average current base price |
| `medianPrice` | Median current base price |
| `minAllInPrice` | Lowest all-in price when supplied |
| `maxAllInPrice` | Highest all-in price when supplied |
| `listingCount` | Number of active listings |
| `ticketCount` | Total ticket inventory |
| `lastPricingRefresh` | Source pricing-refresh timestamp |
| `performers` | Performer IDs and names |
| `sourceUrl` | Canonical Vivid Seats event URL |
| `scrapedAt` | Snapshot timestamp |

### Ticket listing data fields

| Field | Meaning |
|---|---|
| `productionId` | Parent event ID |
| `productionName` | Parent event name |
| `listingId` | Stable listing identifier |
| `section` | Venue section |
| `row` | Seat row when disclosed |
| `quantity` | Available ticket quantity |
| `pricePerTicket` | Base price per ticket |
| `allInPricePerTicket` | All-in price returned by Vivid Seats |
| `localizedPrice` | Localized price when supplied |
| `dealScore` | Vivid Seats deal score |
| `deliveryMethod` | Delivery type |
| `notes` | Listing or entry notes |
| `badges` | Price or quality badges |
| `perks` | Listing perks, such as seated together |
| `instantDelivery` | Whether instant delivery is indicated |
| `sourceUrl` | Parent event URL |
| `scrapedAt` | Snapshot timestamp |

### Example output

```json
{
  "productionId": 7216792,
  "productionName": "Big 12 Mens Basketball Tournament - All Sessions",
  "listingId": "VB16083850183",
  "section": "Upper Level 201",
  "row": "16",
  "quantity": 2,
  "allInPricePerTicket": 417.48,
  "dealScore": 8.7,
  "perks": ["Seated Together"],
  "instantDelivery": false,
  "sourceUrl": "https://www.vividseats.com/.../production/7216792",
  "scrapedAt": "2026-07-21T03:13:46.771Z"
}
```

Inventory and prices change continuously. Example values are illustrative snapshots, not availability guarantees.

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

The Actor uses pay-per-event pricing:

- A small one-time Actor start fee covers browser session startup.
- Each event or ticket-listing record saved is one charged item.
- Apify subscription tiers receive decreasing per-record prices.

Your final cost depends on the number of events and listings returned.

Use event-only mode when you need discovery without listing details.

Use `maxListingsPerEvent` to put a clear ceiling on listing output.

The Apify Console displays the current prices before each run.

### Recurring ticket price monitoring

For a stable monitoring workflow:

1. Save the production IDs you care about.
2. Run the Actor on a schedule.
3. Enable listings and choose a representative listing limit.
4. Export both datasets to your warehouse.
5. Add `scrapedAt` to your time-series key.
6. Compare price, inventory, and listing-level changes between snapshots.

Refreshing production IDs is recommended because completed events and expired inventory stop returning records.

### Tips for reliable runs

- Start with one performer or production ID.
- Prefer direct production IDs for repeated inventory monitoring.
- Keep browser concurrency conservative by using one Actor run per target batch.
- Use an Apify residential proxy if your current network receives a Vivid Seats challenge.
- Avoid very large listing caps until you confirm normal inventory depth.
- Schedule snapshots at a cadence appropriate for the event, not every minute by default.

### Proxy and anti-bot behavior

Vivid Seats uses an Akamai JavaScript challenge.

The Actor launches Chromium, blocks heavy static resources, clears the anonymous challenge, and reuses that browser session for public Hermes JSON calls.

A proxy is optional when anonymous access works from the Actor's network.

If a challenge remains uncleared, configure Apify Proxy with a residential group and retry using a fresh run.

The Actor fails instead of returning an empty success when total extraction fails.

### Apify API with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vivid-seats-events-tickets-scraper').call({
  productionIds: ['7216792'],
  includeListings: true,
  maxEvents: 1,
  maxListingsPerEvent: 50,
  currency: 'USD'
});

console.log(run.status, run.id);
```

### Apify API with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/vivid-seats-events-tickets-scraper').call(run_input={
    'productionIds': ['7216792'],
    'includeListings': True,
    'maxEvents': 1,
    'maxListingsPerEvent': 50,
    'currency': 'USD',
})
print(run['status'], run['id'])
```

### Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~vivid-seats-events-tickets-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productionIds": ["7216792"],
    "includeListings": true,
    "maxEvents": 1,
    "maxListingsPerEvent": 50,
    "currency": "USD"
  }'
```

### MCP integration

Connect the Actor to AI assistants through Apify MCP.

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/vivid-seats-events-tickets-scraper"
```

#### Claude Desktop setup

Add the server to Claude Desktop's MCP configuration.

#### Cursor setup

Use the same HTTP server URL in Cursor's MCP settings.

#### VS Code setup

Add the server to your VS Code MCP configuration or compatible extension.

Claude Desktop, Cursor, and VS Code can use this configuration shape:

```json
{
  "mcpServers": {
    "apify-vivid-seats": {
      "url": "https://mcp.apify.com/?tools=automation-lab/vivid-seats-events-tickets-scraper"
    }
  }
}
```

Example prompts:

- “Extract the next 10 events for this Vivid Seats performer URL.”
- “Snapshot up to 100 ticket listings for production 7216792.”
- “Compare sections and all-in prices from today's listing dataset.”

Use MCP outputs as current marketplace observations, not promises of future ticket availability.

### Integrations

#### Google Sheets

Send scheduled event and listing snapshots to separate worksheets and join on `productionId`.

#### Slack

Trigger an alert when minimum price drops below a threshold or ticket count changes sharply.

#### Webhooks

Notify an internal pricing service after each scheduled run completes.

#### Data warehouses

Load named datasets into BigQuery, Snowflake, PostgreSQL, or a lakehouse for historical analysis.

#### Make and Zapier

Use a completed Actor run as the trigger for inventory reports, alerts, or CRM enrichment.

### Data quality notes

- Prices are numeric values in the requested currency when the source supplies conversion.
- Vivid Seats may not expose every optional field for every listing.
- Row and delivery details depend on seller disclosure.
- Event counts and inventory can change between requests.
- Completed, hidden, or unavailable productions may return no active listings.
- The source can refresh prices after the Actor's snapshot.

### Legal and responsible use

This Actor extracts publicly accessible marketplace data without logging in.

You are responsible for using the data in compliance with applicable laws, Vivid Seats terms, and your contracts.

Do not use the Actor to overload the website, evade access controls, resell restricted personal data, or misrepresent ticket availability.

Keep schedules and limits proportionate to a legitimate business need.

### Troubleshooting

#### Why did the run report an uncleared challenge?

Enable an Apify residential proxy configuration and run again. Network reputation and geography can affect challenge behavior.

#### Why are there no listings for a production ID?

The production may be completed, hidden, sold out, or have expired inventory. Refresh the ID from a current event page.

#### Why is a localized price missing?

Vivid Seats does not return localized values for every currency, country, or listing. Base and all-in fields remain available when supplied.

#### Why did the run fail instead of returning an empty dataset?

The Actor deliberately fails closed when no event data can be extracted. This prevents scheduled monitors from treating a challenge page as a valid zero-inventory snapshot.

### FAQ

#### Does this require a Vivid Seats account?

No. The Actor uses the public anonymous website surfaces.

#### Can it scrape concerts, sports, and theater?

Yes, when those events are listed on public Vivid Seats performer, search, category, or production pages.

#### Can I scrape only events?

Yes. Set `includeListings` to `false`.

#### Can I monitor several events together?

Yes. Supply multiple production IDs and choose `maxEvents` large enough for the batch.

#### Does the Actor buy tickets?

No. It extracts public event and listing data only.

#### Are prices guaranteed at checkout?

No. Resale inventory and fees can change. Treat each output as a timestamped snapshot.

### Related scrapers

Explore other data tools from [automation-lab](https://apify.com/automation-lab) for marketplace monitoring, event discovery, and structured web extraction.

Use this Actor specifically when the source of truth must be Vivid Seats event and live listing data.

### Support

If an input fails, include:

- the Vivid Seats URL or production ID
- whether listings were enabled
- selected currency and limits
- run ID and error message
- whether a proxy was configured

Do not include account credentials or private payment information.

# Actor input Schema

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

Performer, search/category, or event production URLs from vividseats.com.

## `productionIds` (type: `array`):

Optional numeric Vivid Seats production IDs for direct inventory snapshots.

## `includeListings` (type: `boolean`):

Save listing-level section, row, quantity, price, deal score, badges, perks, and delivery details.

## `maxEvents` (type: `integer`):

Maximum event records to save across all inputs.

## `maxListingsPerEvent` (type: `integer`):

Maximum live listing records saved for each event.

## `currency` (type: `string`):

Three-letter ISO currency for returned prices.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time for each Vivid Seats page navigation.

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

Optional Apify Proxy settings. Residential sessions are recommended for blocked or scheduled workloads.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vividseats.com/big-12-mens-basketball-tournament-tickets--sports-ncaa-basketball/performer/81"
    }
  ],
  "productionIds": [],
  "includeListings": true,
  "maxEvents": 10,
  "maxListingsPerEvent": 20,
  "currency": "USD",
  "navigationTimeoutSecs": 45
}
```

# Actor output Schema

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

No description

## `listings` (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/big-12-mens-basketball-tournament-tickets--sports-ncaa-basketball/performer/81"
        }
    ],
    "productionIds": [],
    "maxEvents": 10,
    "maxListingsPerEvent": 20,
    "currency": "USD"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vivid-seats-events-tickets-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/big-12-mens-basketball-tournament-tickets--sports-ncaa-basketball/performer/81" }],
    "productionIds": [],
    "maxEvents": 10,
    "maxListingsPerEvent": 20,
    "currency": "USD",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vivid-seats-events-tickets-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 '{
  "startUrls": [
    {
      "url": "https://www.vividseats.com/big-12-mens-basketball-tournament-tickets--sports-ncaa-basketball/performer/81"
    }
  ],
  "productionIds": [],
  "maxEvents": 10,
  "maxListingsPerEvent": 20,
  "currency": "USD"
}' |
apify call automation-lab/vivid-seats-events-tickets-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vivid Seats Events & Ticket Listings Scraper",
        "description": "🎟️ Extract public Vivid Seats event schedules and live ticket inventory with venue details, prices, sections, rows, quantities, deal scores, perks, and snapshot timestamps.",
        "version": "0.1",
        "x-build-id": "5MuzoyvIWfetk6VY1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vivid-seats-events-tickets-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vivid-seats-events-tickets-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/automation-lab~vivid-seats-events-tickets-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vivid-seats-events-tickets-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/automation-lab~vivid-seats-events-tickets-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vivid-seats-events-tickets-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": {
                    "startUrls": {
                        "title": "🎟️ Vivid Seats URLs",
                        "type": "array",
                        "description": "Performer, search/category, or event production URLs from vividseats.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productionIds": {
                        "title": "Production IDs",
                        "type": "array",
                        "description": "Optional numeric Vivid Seats production IDs for direct inventory snapshots.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeListings": {
                        "title": "Include ticket listings",
                        "type": "boolean",
                        "description": "Save listing-level section, row, quantity, price, deal score, badges, perks, and delivery details.",
                        "default": true
                    },
                    "maxEvents": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum event records to save across all inputs.",
                        "default": 10
                    },
                    "maxListingsPerEvent": {
                        "title": "Maximum listings per event",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum live listing records saved for each event.",
                        "default": 20
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "CAD",
                            "EUR",
                            "GBP",
                            "AUD"
                        ],
                        "type": "string",
                        "description": "Three-letter ISO currency for returned prices.",
                        "default": "USD"
                    },
                    "navigationTimeoutSecs": {
                        "title": "Browser timeout (seconds)",
                        "minimum": 20,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time for each Vivid Seats page navigation.",
                        "default": 45
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Residential sessions are recommended for blocked or scheduled workloads."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```