# Ticketmaster Events Scraper (`devilscrapes/ticketmaster-events-scraper`) Actor

Scrape Ticketmaster event search results by keyword: event name, start date and time, venue, city and state, artists, sold-out and cancelled flags, and event URL, plus flagged parking and VIP add-on rows, as clean deduplicated data.

- **URL**: https://apify.com/devilscrapes/ticketmaster-events-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Other
- **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.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

<p align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />
</p>

## Ticketmaster Events Scraper

**💰 $4.20 / 1 000 results**  ·  pay only for results  ·  no credit card to try

*The devil's in the data.* 😈

Search Ticketmaster by artist, team, venue, or city and get the matching
events as clean, deduplicated rows: name, start date and time, venue,
city and state, performers, status flags, and the event URL, with parking
and VIP add-on listings flagged instead of mixed in blind.

### 🎯 What this scrapes

Ticketmaster's search shows twenty events a page and offers no bulk
export. This Actor runs each query you give it, walks the result pages,
and returns one row per event: name, ISO-8601 UTC start time, time zone,
on-sale date, venue name and page, city, state, country, coordinates,
performers, and sold-out / cancelled / postponed / rescheduled / TBA /
virtual flags. Events sold through partner sites are included and marked
`isPartner`. Parking, VIP, and similar add-on listings attached to an
event come back as their own rows with `rowType: "add_on"`, `isParking`
or `isVip` set, and `parentEventId` pointing at the event.

### 🔥 Features

- 🛡️ **We rotate browser fingerprints** (curl-cffi Chrome, Firefox and
  Safari impersonation) so the site sees a real browser's TLS handshake,
  not a Python script.
- 🔁 **We retry with exponential backoff** on rate limits and server
  errors, honouring `Retry-After`. Up to 5 attempts per page.
- 🌐 **We rotate residential US proxies** through Apify Proxy on every
  block, with a fresh session and exit IP each time.
- 🧊 **Run-wide deduplication.** The same event id never appears twice in
  your dataset, across pages or across queries in one run.
- 🏷️ **Parking and VIP rows are flagged, not dropped.** Keep them, filter
  them on `isParking` / `isVip`, or switch them off with `includeAddOns`.
- 🧱 **Fault isolation.** One query that gets blocked doesn't end the
  others; we log it and keep going.
- 💰 **You pay only for results that land.** No data, no charge (only
  the small `actor-start` warm-up fee).

### 💡 Use cases

- **Ticket resellers and brokers:** monitor which events exist for a team
  or artist, and which are sold out or rescheduled.
- **Travel and hospitality teams:** line up event calendars by city and
  venue to forecast demand.
- **Marketing and sponsorship teams:** track tours and fixtures for the
  artists and teams you care about.
- **Data and analytics:** build event datasets with venue coordinates for
  maps and dashboards.

### ⚙️ How to use it

1. Add one or more search terms to `queries`, for example `lakers` or
   `taylor swift`.
2. Set `maxPages` and `maxItems` to bound how much you pull.
3. Run it, then export to JSON, CSV, or Excel, or pull the dataset
   straight from the Apify API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `queries` | `array<string>` | yes | `lakers` | Search terms: artist, team, venue, or city. |
| `maxPages` | `integer` | no | `3` | Cap on pages fetched per query, about 20 events per page (1-50). |
| `maxItems` | `integer` | no | `100` | Hard cap on total rows across the run, events plus add-ons (1-5000). |
| `includeAddOns` | `boolean` | no | `true` | Also emit parking / VIP add-on rows. |
| `proxyConfiguration` | `object` | yes | Residential, US | Apify Proxy configuration. |

#### Example input

```json
{
  "queries": ["lakers", "taylor swift"],
  "maxPages": 2,
  "maxItems": 120,
  "includeAddOns": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

### 📤 Output

One row per deduplicated event (and per add-on, if enabled).

| Field | Type | Notes |
|---|---|---|
| `eventId` | `string` | Event id, dedupe key. |
| `name` | `string` | Event title. |
| `url` | `string` | Absolute event URL. |
| `rowType` | `string` | `event` or `add_on`. |
| `isParking` | `boolean` | True for parking add-on rows. |
| `isVip` | `boolean` | True for VIP / hospitality add-on rows. |
| `addOnType` | `string \| null` | Add-on category, e.g. `Parking`. |
| `parentEventId` | `string \| null` | The event an add-on belongs to. |
| `startDateUtc` | `string \| null` | ISO-8601 UTC start time. |
| `timeZone` | `string \| null` | IANA time zone of the venue. |
| `onsaleDate` | `string \| null` | ISO-8601 UTC on-sale time. |
| `venueName` | `string \| null` | Venue name. |
| `city` / `state` / `countryCode` | `string \| null` | Venue location. |
| `venueUrl` | `string \| null` | Venue page URL. |
| `latitude` / `longitude` | `number \| null` | Venue coordinates. |
| `artists` | `array<string>` | Performers or teams. |
| `priceFrom` | `string \| null` | Lowest advertised price, when the listing shows one. |
| `isPartner` | `boolean` | Sold through a partner site. |
| `soldOut` / `cancelled` / `postponed` / `rescheduled` / `tba` / `virtual` | `boolean` | Status flags. |
| `ticketingStatus` | `string \| null` | Ticketing status label, if given. |
| `searchQuery` | `string` | Input query that produced this row. |
| `pageNumber` | `integer` | 1-based result page. |
| `scrapedAt` | `string` | UTC ISO-8601 run timestamp. |

#### Example output record

```json
{
  "eventId": "3B006511E92D865F",
  "name": "New York Knicks vs. Los Angeles Lakers",
  "url": "https://www.ticketmaster.com/new-york-knicks-vs-los-angeles-new-york-new-york-01-30-2027/event/3B006511E92D865F",
  "rowType": "event",
  "isParking": false,
  "isVip": false,
  "addOnType": null,
  "parentEventId": null,
  "startDateUtc": "2027-01-31T01:30:00Z",
  "timeZone": "America/New_York",
  "venueName": "Madison Square Garden",
  "city": "New York",
  "state": "NY",
  "countryCode": "US",
  "artists": ["New York Knicks", "Los Angeles Lakers"],
  "isPartner": false,
  "soldOut": false,
  "cancelled": false,
  "searchQuery": "lakers",
  "pageNumber": 1,
  "scrapedAt": "2026-10-12T08:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event: you pay only when these events fire.

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.20 | One-off warm-up charge per run |
| `result-emitted` | $0.004 | Per deduplicated event or add-on row written to the dataset |

Example: 1 000 rows = **$4.20 per run** ($0.20 start + 1000 x $0.004).
No subscription, no minimum, no card required to try it.

### 🚧 Limitations

- **Search-result fields only.** This returns what the search listing
  publishes. Seat maps, live ticket inventory, and checkout data are out
  of scope.
- **Price is often absent.** `priceFrom` is filled only when the listing
  itself carries a price; today most rows leave it empty.
- **United States search.** Queries run against the US site and region.
- **Result depth.** Each query returns about 20 events per page; set
  `maxPages` high enough for the depth you need.
- **Add-ons count as rows.** Parking and VIP rows are billed like any
  other row. Set `includeAddOns` to `false` to skip them.
- **A query with no matches is a success.** It finishes with zero rows
  and a status message naming what was searched.

### ❓ FAQ

**Do I need a Ticketmaster account or API key?**
No. This reads Ticketmaster's public search results.

**How do I tell parking rows from events?**
Use `rowType` (`event` or `add_on`), or the `isParking` / `isVip` flags.
Add-on rows carry `parentEventId` so you can join them to their event.

**Why did my run return fewer rows than `maxItems`?**
Either the search has fewer matches than your cap, or `maxPages` stopped
the run first. The status message tells you which.

**Can I search several terms in one run?**
Yes. Pass an array to `queries`; every row carries `searchQuery` so you
can tell which search found it.

**What happens if a search is blocked?**
We retry up to 5 times with a fresh browser fingerprint and proxy
session each time. If a query still can't be read, the others carry on
and the status message says so. The run ends as failed only when a query
was blocked and nothing at all could be collected.

**Can I run this on a schedule?**
Yes. Use Apify Schedules to re-run your query set on a cadence and catch
newly listed events.

### 💬 Your feedback

Found a bug, or need a field we don't return yet? Open an issue on the
Actor's Issues tab. We read every one.

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

Search terms to look up on Ticketmaster: an artist, team, venue, or city. Each query is paged separately.

## `maxPages` (type: `integer`):

Cap on result pages fetched per query (about 20 events per page).

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

Hard cap on total deduplicated rows (events plus add-ons) emitted across the whole run.

## `includeAddOns` (type: `boolean`):

Also emit parking, VIP and other add-on listings as their own rows, flagged with isParking / isVip and linked to their event by parentEventId. Turn off for events only.

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

Apify Proxy configuration. Residential with a US exit is the default for reliable results.

## Actor input object example

```json
{
  "queries": [
    "lakers",
    "taylor swift"
  ],
  "maxPages": 2,
  "maxItems": 120,
  "includeAddOns": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "queries": [
        "lakers",
        "taylor swift"
    ],
    "maxPages": 2,
    "maxItems": 120,
    "includeAddOns": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/ticketmaster-events-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 = {
    "queries": [
        "lakers",
        "taylor swift",
    ],
    "maxPages": 2,
    "maxItems": 120,
    "includeAddOns": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/ticketmaster-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "lakers",
    "taylor swift"
  ],
  "maxPages": 2,
  "maxItems": 120,
  "includeAddOns": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call devilscrapes/ticketmaster-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,devilscrapes/ticketmaster-events-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nXzOQjCi5CYmchvkE/builds/82xoVRhUz4g04NgiA/openapi.json