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

Search Ticketmaster's US events catalogue by keyword and extract structured event records: id, title, dates, venue, performers, segment/genre. Filter by category, date range, sort order. Up to 1,000 events per run via residential-proxy fetch. Skip sold-out / cancelled / postponed optionally.

- **URL**: https://apify.com/crawlerbros/ticketmaster-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Ticketmaster Scraper

Search Ticketmaster's US events catalogue by keyword and pull structured event records — title, dates, venue, artists, sale status, presale windows. Routes through Apify residential proxy automatically (no input needed) so Ticketmaster's WAF doesn't block the request.

### What it does

You provide a keyword (artist, genre, city + category, etc.); the actor:

1. Walks Ticketmaster's search-results pages (~20 events per page).
2. Extracts events from the embedded server-rendered Next.js state.
3. Normalises each event into a flat record with status flags + nested venue / artist / presale objects.
4. Optionally drops cancelled/postponed/sold-out events.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keyword` | string (required) | `concerts` | Free-text search — artist name, genre, city + category. |
| `maxResults` | integer | `20` (1–1000) | Hard cap on events emitted. |
| `skipSoldOut` | boolean | `false` | Drop events flagged sold-out by Ticketmaster. |
| `skipCancelled` | boolean | `true` | Drop events flagged cancelled, postponed, or rescheduled. |
| `dateFrom` | string (ISO date) | – | Earliest event start date (e.g. `2026-05-01`). Events before this are dropped. |
| `dateTo` | string (ISO date) | – | Latest event start date. Events after this are dropped. |
| `categories` | array of enums | – | Filter to: `concerts`, `sports`, `arts-theater`, `family`, `film`, `miscellaneous`. Multiple allowed. |
| `sort` | enum | `relevance` | One of `relevance`, `date,asc`, `date,desc`, `name,asc`, `name,desc`, `venueName,asc`, `random`. |

#### Example input

```json
{
  "keyword": "taylor swift",
  "maxResults": 60,
  "skipSoldOut": true,
  "skipCancelled": true
}
````

### Output

One record per event, fields below. Empty fields are omitted.

```json
{
  "id": "2D006427A74987FB",
  "discoveryId": "G5eVZ_erE3bLD",
  "title": "James Taylor",
  "url": "https://www.ticketmaster.com/james-taylor-columbia-09-11-2026/event/2D006427A74987FB",
  "startDate": "2026-09-11T23:30:00Z",
  "onsaleDate": "2026-01-16T15:00:00Z",
  "timezone": "America/New_York",
  "isCancelled": false,
  "isPostponed": false,
  "isRescheduled": false,
  "isTBA": false,
  "isVirtual": false,
  "isSoldOut": false,
  "limitedAvailability": false,
  "venueName": "Colonial Life Arena",
  "venueCity": "Columbia",
  "venueState": "SC",
  "venue": {
    "name": "Colonial Life Arena",
    "city": "Columbia",
    "state": "SC",
    "country": "US",
    "countryName": "United States",
    "address": "801 Lincoln St.",
    "postalCode": "29208",
    "url": "https://www.ticketmaster.com/colonial-life-arena/venue/369551",
    "imageUrl": "https://s1.ticketm.net/dbimages/23068v.jpg",
    "latitude": 33.9942619,
    "longitude": -81.036104
  },
  "artists": [
    {
      "name": "James Taylor",
      "url": "https://www.ticketmaster.com/james-taylor/artist/736262",
      "imageUrl": "https://s1.ticketm.net/dam/.../ARTIST_PAGE_3_2.jpg"
    }
  ],
  "artistCount": 1,
  "daysUntilEvent": 269,
  "presaleDates": [
    {"name": "Ticketmaster Presale", "startDateTime": "2026-01-15T15:00:00Z", "endDateTime": "2026-01-16T03:00:00Z"}
  ],
  "scrapedAt": "2024-12-16T14:23:11+00:00"
}
```

#### Output fields

- **`id`** / **`discoveryId`** — Ticketmaster's stable identifiers.
- **`title`** — event / lead artist name.
- **`url`** — direct link to the event ticket page.
- **`startDate`** / **`onsaleDate`** — ISO-8601 timestamps (UTC).
- **`timezone`** — IANA zone for the venue (e.g. `America/New_York`).
- **`isCancelled`** / **`isPostponed`** / **`isRescheduled`** / **`isTBA`** / **`isVirtual`** / **`isSoldOut`** / **`limitedAvailability`** — booleans straight from Ticketmaster.
- **`venueName`** / **`venueCity`** / **`venueState`** — flattened for quick filtering / table display.
- **`venue`** — nested object with the full venue record (name, address, country, lat/lon, image, URL).
- **`artists`** — array of `{name, url, imageUrl}` (lead + supporting acts).
- **`artistCount`** — derived count of items in `artists`.
- **`daysUntilEvent`** — derived integer: days from now (UTC) to `startDate`. Negative for events that have already happened.
- **`presaleDates`** — array of `{name, startDateTime, endDateTime}` for any presale windows.
- **`scrapedAt`** — ISO-8601 timestamp of the run.

### Use cases

- **Demand monitoring** — track when on-sale dates open for hot artists.
- **Tour analytics** — pull every event for an artist + parse city/state for tour-mapping.
- **Resale arbitrage research** — combine Ticketmaster face-value with secondary-market data.
- **Local-events digests** — query "concerts <city>" weekly to populate a curated list.
- **Sold-out alerting** — filter on `isSoldOut: true` and route to a notification.

### FAQ

**Does it need a proxy?**
No setup required. Ticketmaster aggressively blocks datacenter IPs, so the actor automatically uses Apify residential proxy on every request. Each fetch attempt rotates the proxy session ID.

**Is it the official API?**
No — this scraper extracts data from the Ticketmaster website's embedded server-rendered state. For high-volume programmatic access, Ticketmaster offers their own Discovery API (free dev tier at developer.ticketmaster.com).

**Why are some fields missing?**
Ticketmaster doesn't always populate every field. The actor follows an omit-empty contract: fields that aren't present on the source event are simply absent from the record (no nulls).

**How many results can it return?**
Up to `maxResults` (max 1,000). Ticketmaster paginates ~20 events per page; the actor warns and clamps at the cap. For thousands of records, prefer Ticketmaster's official Discovery API.

**Can I search by city / venue / date range?**
Use the keyword field — Ticketmaster's search understands queries like `concerts new york`, `taylor swift dallas`, or `comedy shows this weekend`. For an explicit date window, set `dateFrom` / `dateTo`. For category-only browsing (e.g. all sports events), use the `categories` filter instead of a keyword.

**Why was a specific event skipped?**

- `skipCancelled: true` (default) drops cancelled / postponed / rescheduled events.
- `skipSoldOut: true` drops sold-out events.
- Events without a `title` or `id` are dropped (malformed).

# Actor input Schema

## `keyword` (type: `string`):

What to search for. Free-text — passed verbatim to Ticketmaster's search. Examples: artist name ("Taylor Swift"), genre ("hip hop"), city + category ("concerts new york").

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

Hard cap on event records emitted. Ticketmaster returns ~20 events per page; the actor walks pages until the cap or until results are exhausted.

## `skipSoldOut` (type: `boolean`):

Drop events flagged as `soldOut: true` by Ticketmaster.

## `skipCancelled` (type: `boolean`):

Drop events flagged as cancelled, postponed, or rescheduled.

## `dateFrom` (type: `string`):

Only include events on or after this date. ISO format YYYY-MM-DD. Leave empty for no lower bound.

## `dateTo` (type: `string`):

Only include events on or before this date. ISO format YYYY-MM-DD. Leave empty for no upper bound.

## `categories` (type: `array`):

Limit results to these top-level categories. Empty = all.

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

Result ordering. Default = relevance.

## Actor input object example

```json
{
  "keyword": "concerts",
  "maxResults": 20,
  "skipSoldOut": false,
  "skipCancelled": true,
  "sort": ""
}
```

# 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 = {
    "keyword": "concerts",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "keyword": "concerts",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "keyword": "concerts",
  "maxResults": 20
}' |
apify call crawlerbros/ticketmaster-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ticketmaster Scraper",
        "description": "Search Ticketmaster's US events catalogue by keyword and extract structured event records: id, title, dates, venue, performers, segment/genre. Filter by category, date range, sort order. Up to 1,000 events per run via residential-proxy fetch. Skip sold-out / cancelled / postponed optionally.",
        "version": "0.1",
        "x-build-id": "s38BFwj4xoC3B6ezG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ticketmaster-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~ticketmaster-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~ticketmaster-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "What to search for. Free-text — passed verbatim to Ticketmaster's search. Examples: artist name (\"Taylor Swift\"), genre (\"hip hop\"), city + category (\"concerts new york\")."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on event records emitted. Ticketmaster returns ~20 events per page; the actor walks pages until the cap or until results are exhausted.",
                        "default": 20
                    },
                    "skipSoldOut": {
                        "title": "Skip sold-out events",
                        "type": "boolean",
                        "description": "Drop events flagged as `soldOut: true` by Ticketmaster.",
                        "default": false
                    },
                    "skipCancelled": {
                        "title": "Skip cancelled / postponed",
                        "type": "boolean",
                        "description": "Drop events flagged as cancelled, postponed, or rescheduled.",
                        "default": true
                    },
                    "dateFrom": {
                        "title": "Earliest event date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include events on or after this date. ISO format YYYY-MM-DD. Leave empty for no lower bound."
                    },
                    "dateTo": {
                        "title": "Latest event date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include events on or before this date. ISO format YYYY-MM-DD. Leave empty for no upper bound."
                    },
                    "categories": {
                        "title": "Category filter",
                        "type": "array",
                        "description": "Limit results to these top-level categories. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "concerts",
                                "sports",
                                "arts-theater",
                                "family",
                                "miscellaneous",
                                "film"
                            ]
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "",
                            "date,asc",
                            "date,desc",
                            "name,asc",
                            "name,desc",
                            "venueName,asc",
                            "random"
                        ],
                        "type": "string",
                        "description": "Result ordering. Default = relevance.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```