# Ticketmaster Scraper (`solidcode/ticketmaster-scraper`) Actor

\[💰 $2.0 / 1K] Extract live events from Ticketmaster — concerts, sports, theater, arts, and family shows. Search by keyword or paste Ticketmaster URLs. Returns one row per event with venue, geo coordinates, dates, on-sale and presale times, lineup, and availability status.

- **URL**: https://apify.com/solidcode/ticketmaster-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

## Ticketmaster Scraper

Pull live events from Ticketmaster at scale — concerts, sports, theater, arts, and family shows — with venue geocoordinates, start dates, presale and on-sale windows, full artist lineups, category, and live availability status, one clean row per event. Search by keyword, browse a category in any city, or paste Ticketmaster URLs straight in. Built for event-discovery platforms, market analysts, and venue and promoter lead teams who need structured, current event data without clicking through Ticketmaster page by page.

### Why This Scraper?

- **Five event categories in one actor** — Music, Sports, Arts & Theatre, Family, and Miscellaneous, switchable from a single dropdown when paired with a city.
- **Latitude and longitude on every venue** — plus venue name, full street address, city, state, country, postal code, and venue page URL, so events drop straight onto a map.
- **Presale and on-sale dates captured** — every presale window (name, start, and end times) alongside the public on-sale date, so you can act before tickets go live.
- **Full artist and attraction lineups** — each performer's name and Ticketmaster page, plus a portrait image for the headliner.
- **13 Ticketmaster marketplaces** — search the US (default), Canada, UK, Ireland, Australia, New Zealand, Germany, France, Spain, Netherlands, Belgium, Sweden, or Mexico.
- **Live availability flags** — sold-out, limited-availability, ticketing status, plus cancelled, postponed, rescheduled, TBA, and virtual flags on every event.
- **Date-window filtering at the source** — set an earliest and latest event date (YYYY-MM-DD) and only matching events are billed.
- **Up to 10,000 events per run** — set Maximum Results to 0 for unlimited and the actor walks every page until the marketplace is exhausted.
- **~35 fields per event, one flat row** — event name, ID, URL, timezone, category and genre, promoter and partner flags, and an event image, ready for any spreadsheet or database with no nested unpacking.

### Use Cases

**Event Discovery & Aggregation**
- Build a "what's on near me" feed by browsing a category in any city
- Aggregate every concert for a touring artist across multiple marketplaces
- Power a calendar app with start dates, timezones, and on-sale countdowns
- Surface family and arts events for a local listings site

**Market & Competitive Research**
- Track which artists and tours are routing through a region
- Map event density by venue, city, and category over a date window
- Monitor sold-out and limited-availability rates as a demand signal
- Compare event supply across US, UK, and EU Ticketmaster marketplaces

**Lead Generation**
- Build venue contact lists with name, full address, and venue page URL
- Identify active promoters by category and city for outreach
- Source touring artists and attractions for booking and sponsorship pitches
- Target high-frequency venues for partnership programs

**Travel & Hospitality Planning**
- Match hotel and travel packages to events by venue geocoordinates and date
- Plan around presale and on-sale windows for high-demand shows
- Cluster events by city and weekend for trip-planning tools

**Data Enrichment & Integration**
- Enrich a ticketing or CRM database with canonical event IDs and venue geo
- Feed live availability status into alerting and dashboard systems
- Backfill artist lineups and category labels onto existing event records

### Getting Started

#### Search by Keyword

The simplest run — one artist, team, or show name:

```json
{
    "searchTerms": ["Taylor Swift"],
    "maxResults": 100
}
````

#### Browse a Category in a City

Category browsing works when you pair it with a city:

```json
{
    "category": ["music"],
    "location": "Los Angeles",
    "countryCode": "US",
    "sort": "date",
    "maxResults": 200
}
```

#### Filter by Date Window

Restrict results to events in a specific date range:

```json
{
    "searchTerms": ["comedy"],
    "startDateFrom": "2026-07-01",
    "startDateTo": "2026-07-31",
    "sort": "date",
    "maxResults": 100
}
```

#### Search a Non-US Marketplace

```json
{
    "category": ["sports"],
    "location": "Toronto",
    "countryCode": "CA",
    "maxResults": 100
}
```

#### Paste Ticketmaster URLs

Already built a filtered search on the Ticketmaster website? Paste it in:

```json
{
    "startUrls": [
        "https://www.ticketmaster.com/search?q=u2",
        "https://www.ticketmaster.com/discover/concerts/new-york"
    ],
    "maxResults": 200
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["Taylor Swift"]` | Keywords to search — an artist, team, show, or venue. Each term runs as its own search. |
| `startUrls` | string\[] | `[]` | Paste Ticketmaster search or discover URLs directly. Each is scraped exactly as given. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | select\[] | `[]` | Browse one or more categories: Music, Sports, Arts & Theatre, Family, Miscellaneous. Requires a Location. Ignored when a search term is used. |
| `location` | string | — | City to browse events in (e.g. "Los Angeles"). Required when browsing by Category. |
| `countryCode` | select | `US` | Ticketmaster marketplace: US, Canada, UK, Ireland, Australia, New Zealand, Germany, France, Spain, Netherlands, Belgium, Sweden, or Mexico. |
| `startDateFrom` | string | — | Only include events starting on or after this date (YYYY-MM-DD). |
| `startDateTo` | string | — | Only include events starting on or before this date (YYYY-MM-DD). |
| `sort` | select | `Relevance` | Order results by Relevance or Date (soonest first). |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum events to collect across all searches and URLs. Set to 0 for unlimited (a 10,000-event safety cap still applies). |

### Output

Each event is returned as one flat row. Here is a representative result:

```json
{
    "name": "Coldplay: Music Of The Spheres World Tour",
    "eventId": "vvG1zZ9bWb1xyz",
    "discoveryId": "Z7r9jZ1A7xyz",
    "url": "https://www.ticketmaster.com/event/0E00612A1B2C3D4E",
    "startDate": "2026-08-14",
    "endDate": "2026-08-14",
    "onSaleDate": "2026-03-15T15:00:00Z",
    "dateDisplayMode": "showDateTime",
    "spanMultipleDays": false,
    "presaleDates": [
        { "name": "Artist Presale", "startDateTime": "2026-03-12T15:00:00Z", "endDateTime": "2026-03-14T22:00:00Z" }
    ],
    "venueName": "SoFi Stadium",
    "venueCity": "Inglewood",
    "venueState": "CA",
    "venueCountry": "US",
    "venueAddress": "1001 Stadium Dr",
    "venuePostalCode": "90301",
    "venueUrl": "https://www.ticketmaster.com/sofi-stadium-inglewood-tickets-los-angeles/venue/229227",
    "latitude": 33.9534,
    "longitude": -118.3387,
    "timeZone": "America/Los_Angeles",
    "category": "Music",
    "categoryId": "KZFzniwnSyZfZ7v7nJ",
    "artists": [
        { "name": "Coldplay", "url": "https://www.ticketmaster.com/coldplay-tickets/artist/806431" }
    ],
    "imageUrl": "https://s1.ticketm.net/dam/a/abc/example_RETINA_PORTRAIT_16_9.jpg",
    "soldOut": false,
    "limitedAvailability": false,
    "ticketingStatus": "onsale",
    "cancelled": false,
    "postponed": false,
    "rescheduled": false,
    "tba": false,
    "virtual": false,
    "partnerEvent": false,
    "sourceQuery": "search: Coldplay",
    "scrapedAt": "2026-05-30T14:30:00Z"
}
```

#### Event Core

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Event title |
| `eventId` | string | Ticketmaster event identifier |
| `discoveryId` | string | Ticketmaster Discovery API identifier |
| `url` | string | Direct Ticketmaster event page URL |
| `category` | string | Top-level category (Music, Sports, Arts & Theatre, Family, Miscellaneous) |
| `categoryId` | string | Ticketmaster category (segment) identifier |
| `sourceQuery` | string | Which search term or URL produced this row |
| `scrapedAt` | string | ISO 8601 timestamp of data extraction |

#### Date & Sale

| Field | Type | Description |
|-------|------|-------------|
| `startDate` | string | Event start date |
| `endDate` | string | Event end date |
| `onSaleDate` | string | Public on-sale date and time |
| `presaleDates` | object\[] | Presale windows: name, start, and end times |
| `dateDisplayMode` | string | How the date is displayed (showDateTime / showDate) |
| `spanMultipleDays` | boolean | Whether the event runs across multiple days |
| `timeZone` | string | Venue timezone (e.g. America/Los\_Angeles) |

#### Venue & Location

| Field | Type | Description |
|-------|------|-------------|
| `venueName` | string | Venue name |
| `venueCity` | string | Venue city |
| `venueState` | string | Venue state or region |
| `venueCountry` | string | Venue country code |
| `venueAddress` | string | Venue street address |
| `venuePostalCode` | string | Venue postal code |
| `venueUrl` | string | Ticketmaster venue page URL |
| `latitude` | number | Venue latitude |
| `longitude` | number | Venue longitude |

#### Classification & Artists

| Field | Type | Description |
|-------|------|-------------|
| `artists` | object\[] | Performers and attractions: name and Ticketmaster page URL |
| `imageUrl` | string | Headliner portrait image, with venue image as fallback |

#### Media & Status

| Field | Type | Description |
|-------|------|-------------|
| `soldOut` | boolean | Whether the event is sold out |
| `limitedAvailability` | boolean | Whether availability is limited |
| `ticketingStatus` | string | Current ticketing status (e.g. onsale, offsale) |
| `cancelled` | boolean | Cancelled flag |
| `postponed` | boolean | Postponed flag |
| `rescheduled` | boolean | Rescheduled flag |
| `tba` | boolean | Date-to-be-announced flag |
| `virtual` | boolean | Virtual-event flag |
| `partnerEvent` | boolean | Whether the listing is a partner or resale event |

### Tips for Best Results

- **Category filters need a city** — Category browsing only runs when you also set a Location. Pair them, or the run will skip the category and tell you to add a city.
- **Use search terms for everything-everywhere** — a keyword like "Taylor Swift" searches the entire selected country at once; a category browse is always scoped to one city.
- **Set the right marketplace for the city** — match `countryCode` to the city's country (e.g. "London" with UK, not US) so same-named cities resolve correctly.
- **Sort by Date for upcoming-event feeds** — choose Date (soonest first) so the earliest shows lead your results; Relevance is best for artist and team searches.
- **Tighten the date window to control cost** — `startDateFrom` and `startDateTo` filter at the source, so you only pay for events inside your range.
- **Results arrive in full pages of 20** — a small Maximum Results may return a complete page of 20; set it to 0 for an exhaustive pull up to the 10,000-event cap.
- **Paste pre-filtered URLs to reuse your work** — if you have already built a search on the Ticketmaster website, paste that URL into `startUrls` and it runs exactly as shown.

### Pricing

**$2.00 per 1,000 results** — flat, pay only for the events you collect. No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.20 |
| 1,000 | $2.00 |
| 10,000 | $20.00 |
| 100,000 | $200.00 |

A "result" is one event row in the output dataset. Platform fees (storage and data transfer) are billed by Apify according to your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate event discovery, market research, and lead generation. You are responsible for complying with applicable laws and Ticketmaster's Terms of Service. Do not use extracted data for spam, harassment, ticket-resale fraud, or any unlawful purpose. Treat any personal data encountered with care and in line with applicable privacy regulations.

# Actor input Schema

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

Keywords to search on Ticketmaster — an artist, team, show, or venue (e.g. 'Taylor Swift', 'Lakers', 'Hamilton'). Each term runs as its own search. Leave empty if you are pasting URLs instead.

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

Paste Ticketmaster search or event URLs directly (e.g. 'https://www.ticketmaster.com/search?q=u2'). Each URL is scraped exactly as given — handy if you have already built a filtered search on the Ticketmaster website.

## `category` (type: `array`):

Browse events in these categories. Category browsing needs a Location too (set a city below). Categories are ignored when you use a search term — keyword search already covers every category.

## `location` (type: `string`):

City to browse events in (e.g. 'Los Angeles', 'New York'). Required when you browse by Category. Not used with search terms — those search everywhere in the selected country.

## `countryCode` (type: `string`):

Which Ticketmaster marketplace to search.

## `startDateFrom` (type: `string`):

Only include events starting on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

## `startDateTo` (type: `string`):

Only include events starting on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `sort` (type: `string`):

How to order results. 'Date' shows the soonest events first. Sorting applies to search terms and pasted search URLs.

## `maxResults` (type: `integer`):

Maximum total number of events to collect across all searches and URLs. Set to 0 for unlimited, in which case a safety cap of 10,000 events still applies. Each event counts as one result.

## Actor input object example

```json
{
  "searchTerms": [
    "Taylor Swift"
  ],
  "startUrls": [],
  "category": [],
  "countryCode": "US",
  "sort": "relevance",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

All scraped events with the key fields: name, date, venue, location, and status.

# 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 = {
    "searchTerms": [
        "Taylor Swift"
    ],
    "startUrls": [],
    "category": [],
    "countryCode": "US",
    "sort": "relevance",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ticketmaster-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 = {
    "searchTerms": ["Taylor Swift"],
    "startUrls": [],
    "category": [],
    "countryCode": "US",
    "sort": "relevance",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ticketmaster-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 '{
  "searchTerms": [
    "Taylor Swift"
  ],
  "startUrls": [],
  "category": [],
  "countryCode": "US",
  "sort": "relevance",
  "maxResults": 100
}' |
apify call solidcode/ticketmaster-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ticketmaster Scraper",
        "description": "[💰 $2.0 / 1K] Extract live events from Ticketmaster — concerts, sports, theater, arts, and family shows. Search by keyword or paste Ticketmaster URLs. Returns one row per event with venue, geo coordinates, dates, on-sale and presale times, lineup, and availability status.",
        "version": "1.0",
        "x-build-id": "8OmfdfpKPT5cHdhZ6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~ticketmaster-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-ticketmaster-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/solidcode~ticketmaster-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-ticketmaster-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/solidcode~ticketmaster-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-ticketmaster-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search on Ticketmaster — an artist, team, show, or venue (e.g. 'Taylor Swift', 'Lakers', 'Hamilton'). Each term runs as its own search. Leave empty if you are pasting URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Ticketmaster URLs",
                        "type": "array",
                        "description": "Paste Ticketmaster search or event URLs directly (e.g. 'https://www.ticketmaster.com/search?q=u2'). Each URL is scraped exactly as given — handy if you have already built a filtered search on the Ticketmaster website.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Browse events in these categories. Category browsing needs a Location too (set a city below). Categories are ignored when you use a search term — keyword search already covers every category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "music",
                                "sports",
                                "arts-theatre",
                                "family",
                                "miscellaneous"
                            ],
                            "enumTitles": [
                                "Music",
                                "Sports",
                                "Arts & Theatre",
                                "Family",
                                "Miscellaneous"
                            ]
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Location (City)",
                        "type": "string",
                        "description": "City to browse events in (e.g. 'Los Angeles', 'New York'). Required when you browse by Category. Not used with search terms — those search everywhere in the selected country."
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "IE",
                            "AU",
                            "NZ",
                            "DE",
                            "FR",
                            "ES",
                            "NL",
                            "BE",
                            "SE",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Which Ticketmaster marketplace to search.",
                        "default": "US"
                    },
                    "startDateFrom": {
                        "title": "Earliest Event Date",
                        "type": "string",
                        "description": "Only include events starting on or after this date (YYYY-MM-DD). Leave empty for no lower bound."
                    },
                    "startDateTo": {
                        "title": "Latest Event Date",
                        "type": "string",
                        "description": "Only include events starting on or before this date (YYYY-MM-DD). Leave empty for no upper bound."
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "How to order results. 'Date' shows the soonest events first. Sorting applies to search terms and pasted search URLs.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of events to collect across all searches and URLs. Set to 0 for unlimited, in which case a safety cap of 10,000 events still applies. Each event counts as one result.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
