# Ticketmaster Scraper \[Only $2/1K💰] | Events | Ticket Status (`ahmed_jasarevic/ticketmaster-scraper`) Actor

Scrape Ticketmaster events — concerts, sports and theater with venue, dates, ticket status, lineups and images. No API key needed, $0.002 per event.

- **URL**: https://apify.com/ahmed_jasarevic/ticketmaster-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 results

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

Learn more: https://docs.apify.com/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

## Ticketmaster Scraper

Scrape **Ticketmaster events** — concerts, sports, theater and family shows — with event name, date/time, venue + city, category/genre, ticket status (on sale / limited / sold out / cancelled), ticket URL, artist lineup, seatmap and images. Built for event promoters, ticket resellers, market researchers, travel/fan apps and data journalists — and it needs **no API key**: the actor reads Ticketmaster's own internal public JSON API at **$0.002 per event**, the cheapest no-key option verified on the Apify Store.

### Main Use Cases

- **Live events database** — build clean event datasets per market, category or artist, with dates, venues, lineups and ticket status
- **Sold-out event tracking** — scheduled daily runs detect when events go from on-sale to sold out or cancelled
- **Concert price tracking** — monitor face-value price ranges and currency where Ticketmaster publishes them
- **Event market research** — tour activity, genre mix and venue usage per city and country
- **Promoter lead generation** — identify active events, artists and venues per market for outreach planning

### How It Works — No Browser, No API Key

Ticketmaster's rendered pages sit behind a bot manager (EPSF/Radware) that blocks plain HTTP fetches. Instead of a headless browser, the actor talks to **Ticketmaster's own internal public JSON API** — the same endpoints the ticketmaster.com Next.js frontend queries:

- **Listing:** `GET https://www.ticketmaster.com/api/search/events?q={query}&page={n}&region={region}&startDate=&endDate=`
- **Category browse:** `GET https://www.ticketmaster.com/api/search/events/category/{categoryId}?page={n}&region={region}…`
- **Event detail:** `GET https://www.ticketmaster.com/api/eventinfo/{discoveryId}`

A Rust-based HTTP client impersonating real Chrome TLS/HTTP2 (`@crawlee/impit-client`) clears the bot manager's TLS fingerprinting without a browser (~256 MB, no Chromium). Ticketmaster also filters by IP reputation, so the actor walks an **egress ladder**: pass 1 direct (free); requests that come back HTTP 403 are replayed automatically through Apify Proxy **RESIDENTIAL**, then RESIDENTIAL with a Firefox fingerprint as a last resort. `autoProxyOnBlock: false` disables the fallback for zero proxy spend. No datacenter proxy tier is used (it rejects the TLS-impersonating client).

### Collect Live Event Data Without the Discovery API

The official Ticketmaster Discovery API requires a developer key from a paid partner agreement, and the mobile gateway is not publicly routable. This actor uses the www JSON API — the only key-free, publicly routable machine-readable surface — while competitor `labrat011/event-ticket-scraper` at $0.0005 relies on an official `apiKey` input. At $0.002/event this is the **cheapest no-api-key Ticketmaster scraper** on the Store (the nearest key-free competitor is $0.00225).

Every run also includes one **built-in showcase event** (`SHOWCASE_EVENT` — currently "Eagles Live at Sphere"), always fetched through `/api/eventinfo` with full enrichment, so the output demonstrates the difference the `includeEventDetails` enrichment makes. Turn it off with `includeShowcaseEvent: false`.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchQueries` | array | No | `[]` | Keyword queries to `/api/search/events`, e.g. `beyonce`, `comedy`. Empty = category IDs only |
| `categoryIds` | array | No | `[]` | Major-category IDs: Music `KZFzniwnSyZfZ7v7nJ`, Sports `KZFzniwnSyZfZ7v7v1`, Arts & Theater `KZFzniwnSyZfZ7v7nK`, Family `KZFzniwnSyZfZ7v7nJ2` |
| `startUrls` | array | No | `[]` | Direct Ticketmaster event URLs, e.g. `https://www.ticketmaster.com/artist/event/1A9Zk37GkdXVozi` |
| `startDate` / `endDate` | string | No | `""` | `YYYY-MM-DD` event start-date window (empty end = no upper bound) |
| `countryCode` | string | No | `US` | Market host: `US`, `GB`, `DE`, `AU`, `CA`, … |
| `region` | string | No | `200` | Ticketmaster region code (`200` = United States / all regions) |
| `includeEventDetails` | boolean | No | `true` | Enrich each event via `/api/eventinfo`: venue address/coords, full artist lineup, images, currency |
| `includeShowcaseEvent` | boolean | No | `true` | Add the built-in always-enriched reference event |
| `maxItems` | integer | No | `100` | Hard cap on events (free users: 10) |
| `maxPagesPerQuery` | integer | No | auto | Optional cap on result pages (20 events each); auto-derived from `maxItems` |
| `maxConcurrency` | integer | No | `6` | Parallel requests (1–20); the main speed knob |
| `maxRequestRetries` | integer | No | `3` | Retries for a failed HTTP request |
| `requestHandlerTimeoutSecs` | integer | No | `60` | Per-request timeout in seconds |
| `autoProxyOnBlock` | boolean | No | `true` | Replay blocked requests through Apify Proxy RESIDENTIAL |
| `proxy` | object | No | off | Standard Apify proxy picker (used from the first pass when enabled) |

### Output — Event Records for Market Research

One dataset item per event (see **Example Output** below).

**Data table:**

| Field | Description |
|---|---|
| `eventName`, `eventId`, `discoveryId`, `sourceId` | Event identity across Ticketmaster systems |
| `startDate`, `startDateTimeLocal`, `endDateTimeLocal`, `timeZone` | When the event happens |
| `onsaleDate`, `offsaleDate` | Ticket sale window |
| `venueName`, `venueCity`, `venueState`, `venueCountry`, `venueAddress`, `venueLatitude`, `venueLongitude`, `venueUrl` | Where it happens |
| `category`, `subCategory`, `genre`, `subGenre` | Ticketmaster taxonomy |
| `priceMin`, `priceMax`, `currencyCode` | Face-value range when published (often `null`, see limitation) |
| `ticketStatus` | `ON_SALE`, `LIMITED_AVAILABILITY`, `SOLD_OUT`, `CANCELLED`, `POSTPONED`, `RESCHEDULED`, `TBA` |
| `ticketUrl` | Canonical Ticketmaster event page |
| `artists` | Lineup with artist page URLs, images and rank |
| `seatmapUrl`, `imageUrl`, `images` | Static seatmap image and event/artist photos |

> **Known limitation:** Ticketmaster only publishes face-value pricing inside the bot-walled checkout flow (a FlatBuffer/AVSC payload), so `priceMin`/`priceMax` are usually `null` while `currencyCode` is always present. Prices shown on listing cards are dynamic resale values and are not exposed by any public endpoint.

### Example Input

Keyword search with enrichment:

```json
{
    "searchQueries": ["beyonce"],
    "countryCode": "US",
    "region": "200",
    "includeEventDetails": true,
    "maxItems": 50,
    "maxPagesPerQuery": 2
}
```

One specific event by URL:

```json
{
    "startUrls": ["https://www.ticketmaster.com/eagles-live-at-sphere-las-vegas-nevada-11-14-2026/event/17006484FED61E34"],
    "countryCode": "US",
    "includeEventDetails": true
}
```

### Example Output — Event Record (trimmed)

```json
{
    "eventName": "JAY-Z30",
    "eventId": "0A0064C8CED8B734",
    "discoveryId": "vvG1IZ_GNCU5jV",
    "startDate": "2026-10-23T20:00-07:00",
    "timeZone": "America/Los_Angeles",
    "onsaleDate": "2026-06-12T10:00-07:00",
    "venueName": "SoFi Stadium",
    "venueCity": "Inglewood",
    "venueState": "CA",
    "venueAddress": "1001 S. Stadium Dr",
    "venueLatitude": 33.950529,
    "venueLongitude": -118.343767,
    "category": "Music",
    "genre": "Hip-Hop/Rap",
    "currencyCode": "USD",
    "ticketStatus": "ON_SALE",
    "ticketUrl": "https://www.ticketmaster.com/jayz30-inglewood-california-10-23-2026/event/0A0064C8CED8B734",
    "artists": [{ "name": "JAŸ-Z", "url": "https://www.ticketmaster.com/jayz-tickets/artist/781009" }],
    "seatmapUrl": "https://mapsapi.tmol.io/maps/geometry/3/event/0A0064C8CED8B734/staticImage?type=png&systemId=HOST",
    "imageUrl": "https://s1.ticketm.net/dam/a/…_EVENT_DETAIL_PAGE_16_9.jpg"
}
```

### Track Concert and Sports Events at $0.002 Per Event

**One price, one line, no options:** the actor bills every dataset row automatically via Apify's `apify-default-dataset-item` event at **$0.002 per event** plus Apify's standard $0.00005 actor start. `includeEventDetails` does not change the price — enriching an event or not costs the same per row; it only changes how fast the run finishes. Free Apify accounts are capped at 10 events per run; paid plans run uncapped. Budget separately for residential proxy traffic only if you get blocked (requests replayed through RESIDENTIAL are billed by Apify at standard proxy rates on top of compute).

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — daily runs with a date window track status changes (onsale → sold out → cancelled) over time
- **Webhooks** — push new/changed events to your app, alerting or warehouse
- **Export** — JSON, CSV, Excel, XML, HTML

**Recommended schedule**: weekly for event databases per market; daily for sold-out/schedule-change tracking with a `startDate` window.

### Related Actors

- [Ticketmaster Scraper](https://apify.com/solidcode/ticketmaster-scraper) — `solidcode/ticketmaster-scraper` — closest key-free competitor; $0.00225/event
- [Ticketmaster Events Scraper 🎫](https://apify.com/easyapi/ticketmaster-events-scraper) — `easyapi/ticketmaster-events-scraper` — $0.00499/event + $0.09 start
- [Ticketmaster Scraper | Events, Tickets & Seat-Level Prices](https://apify.com/lentic_clockss/ticketmaster-scraper) — `lentic_clockss/ticketmaster-scraper` — $0.003/event + $0.005 start, seat-level pricing
- [Ticketmaster Event Scraper](https://apify.com/labrat011/event-ticket-scraper) — `labrat011/event-ticket-scraper` — $0.0005/event but **requires the official Discovery API key**
- [Ticketmaster Radar — Presale Codes, Alerts & On-Sale](https://apify.com/bovi/ticketmaster-radar) — `bovi/ticketmaster-radar` — stateful change-feed for presale/on-sale tracking

### FAQ

#### Why use this actor instead of the official Ticketmaster API?

The official Discovery API requires a developer key from a paid partner agreement, and the mobile gateway is not publicly routable. This actor reads Ticketmaster's www JSON API — the only key-free, publicly routable machine-readable surface — with TLS impersonation and an automatic residential-proxy fallback for IP blocks.

#### What are alternatives to this actor for concert event data?

Key-free Store options: [solidcode/ticketmaster-scraper](https://apify.com/solidcode/ticketmaster-scraper) ($0.00225/event), [easyapi/ticketmaster-events-scraper](https://apify.com/easyapi/ticketmaster-events-scraper) ($0.00499 + $0.09 start), [lentic_clockss/ticketmaster-scraper](https://apify.com/lentic_clockss/ticketmaster-scraper) ($0.003 + $0.005 start). If you already hold a Discovery API key, [labrat011/event-ticket-scraper](https://apify.com/labrat011/event-ticket-scraper) is cheaper ($0.0005). Ours is the cheapest key-free option.

#### How can I scrape Ticketmaster without an API key?

Point the actor at Ticketmaster's internal `api/search/events` and `api/eventinfo` endpoints via `searchQueries`/`categoryIds`/`startUrls`. No key input exists on this actor — the only requirements are the TLS impersonation and, when IP-blocked, a residential replay.

#### How do I track sold-out shows?

Schedule daily runs with a `startDate` window and read the `ticketStatus` field (`ON_SALE`, `LIMITED_AVAILABILITY`, `SOLD_OUT`, `CANCELLED`, `POSTPONED`, `RESCHEDULED`, `TBA`). Each run also returns the dates and onsale windows needed to detect schedule changes.

#### Why are prices empty on my events?

Ticketmaster serves face-value pricing only inside the bot-walled checkout flow. `currencyCode` is always present; `priceMin`/`priceMax` stay `null` unless the API payload carries them. Resale prices shown on listing cards are not exposed by any public endpoint.

#### Why did my run log "Pass 2/3 — Apify Proxy group RESIDENTIAL"?

Ticketmaster refused the first (direct, free) pass — HTTP 403 on Apify's datacenter IPs. Only the blocked requests were replayed through residential IPs, so you still get data. Set `autoProxyOnBlock: false` to stay direct for zero proxy spend (at the risk of an empty run from datacenter IPs).

#### Does it work outside the US?

Yes — set `countryCode` to switch market hosts (`GB`, `DE`, `AU`, `CA`, …). Some smaller markets return fewer fields.

### For AI Agents & LLM Apps

- **Purpose**: given keyword queries, Ticketmaster category IDs, or direct event URLs, returns one structured row per event with dates, venue + geo-coordinates, category/genre, ticket status, ticket URL, artist lineup, seatmap and images.
- **Minimal working input**:

```json
{ "searchQueries": ["beyonce"], "countryCode": "US", "region": "200", "maxItems": 10, "includeEventDetails": true }
```

- **Variant inputs**: category browse — `{ "categoryIds": ["KZFzniwnSyZfZ7v7nJ"], "maxItems": 50 }`; single event — `{ "startUrls": ["https://www.ticketmaster.com/artist/event/1A9Zk37GkdXVozi"] }`; date window — add `"startDate": "2026-11-01", "endDate": "2026-12-31"`.
- **Output fields**: `eventName, eventId, discoveryId, sourceId, startDate, startDateTimeLocal, endDateTimeLocal, timeZone, onsaleDate, offsaleDate, venueName, venueCity, venueState, venueCountry, venueAddress, venueLatitude, venueLongitude, venueUrl, category, subCategory, genre, subGenre, priceMin, priceMax, currencyCode, ticketStatus, ticketUrl, artists, seatmapUrl, imageUrl, images`.
- **Behaviors an agent should know**: with no input at all, the actor defaults to upcoming Music events for the next 90 days — always pass at least one of `searchQueries`/`categoryIds`/`startUrls`. `includeEventDetails` (default `true`) adds one `/api/eventinfo` call per event but does not change price — only runtime. A built-in showcase event ("Eagles Live at Sphere") is added to every run unless `includeShowcaseEvent: false`. `maxItems` caps events; `maxPagesPerQuery` is auto-derived when omitted (20 events/page). `autoProxyOnBlock` (default `true`) replays HTTP 403 responses through residential proxies billed separately by Apify — set it `false` for zero proxy spend. `countryCode` switches market hosts (`GB`, `DE`, `AU`, `CA`); `region` defaults to `200` (US). `priceMin`/`priceMax` are usually `null` — this is a Ticketmaster platform limitation, not a bug; do not retry events to recover prices.
- **Billing**: pay-per-result — $0.002 per dataset row + standard $0.00005 actor start; residential proxy replay (only when blocked) is billed separately by Apify.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Ticketmaster, Live Nation, or any of their affiliates. It accesses only Ticketmaster's own publicly served JSON endpoints with the same headers its website uses; it does not bypass login walls or access private data. Respect Ticketmaster's Terms of Use and applicable law, and do not use the data for unauthorized resale or ticket-scalping activities prohibited by applicable law. You are responsible for your own compliance with Ticketmaster's Terms of Service and applicable data-protection law.

### SEO Keywords

ticketmaster scraper, concert event data, event discovery api alternative, event ticketing data, sold out event tracking, event market research, ticket resale analysis, live events database, concert price tracking, ticketmaster api without key, venue capacity data, band tour data scraping, event calendar data, promoter lead generation, events by city data, ticketmaster discovery api, concert industry analytics, artist performance tracking, event aggregation api, secondary market ticket research

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword queries passed to Ticketmaster's /api/search/events endpoint, e.g. beyonce, coldplay, comedy. Leave empty to only use category IDs.

## `includeShowcaseEvent` (type: `boolean`):

Adds one built-in reference event (currently "Eagles Live at Sphere") to every run, always fetched with the full /api/eventinfo enrichment - venue address and coordinates, complete artist lineup, images, currency and ticket status. It is a single extra request and it is what shows the difference the `includeEventDetails` enrichment makes. Turn it off to scrape only your own input.

## `categoryIds` (type: `array`):

Ticketmaster major-category IDs to browse via /api/search/events/category/{categoryId}. Music = KZFzniwnSyZfZ7v7nJ, Sports = KZFzniwnSyZfZ7v7v1, Arts & Theater = KZFzniwnSyZfZ7v7nK, Family = KZFzniwnSyZfZ7v7nJ2.

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

Direct Ticketmaster event detail URLs, e.g. https://www.ticketmaster.com/artist/event/1A9Zk37GkdXVozi. Used to scrape specific events.

## `startDate` (type: `string`):

Only return events starting on or after this date. Format YYYY-MM-DD.

## `endDate` (type: `string`):

Only return events starting on or before this date. Format YYYY-MM-DD. Leave empty for no upper bound.

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

Two-letter market country code used for the site host (e.g. US, GB, DE, AU, CA).

## `region` (type: `string`):

Ticketmaster region code. 200 = United States / all regions.

## `includeEventDetails` (type: `boolean`):

Fetch /api/eventinfo/{eventId} for every discovered event to enrich it with venue address, categories, full artist lineup, images and currency.

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

Hard cap on the number of events pushed to the dataset.

## `maxPagesPerQuery` (type: `integer`):

Hard cap on result pages (20 events each) requested per query or category. Leave empty to let maxItems decide: the actor pages as deep as needed to reach maxItems and stops on its own when a query runs out of results.

## `maxRequestRetries` (type: `integer`):

Number of retries for a failed HTTP request.

## `maxConcurrency` (type: `integer`):

How many requests are sent at the same time. Each residential request takes 1.5-2 s, so this is what decides how long a run takes: at the default 6 a 100-event enriched run finishes several times faster than at 2. Lower it to 2 if you see more HTTP 403 blocks on your market.

## `requestHandlerTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## `autoProxyOnBlock` (type: `boolean`):

Ticketmaster answers HTTP 403 to Apify's datacenter IPs. When enabled, every request that comes back blocked is replayed through the Apify Proxy RESIDENTIAL group instead of failing the run (residential proxy traffic is billed on top of compute). Turn it off to stay on a direct connection only.

## `proxy` (type: `object`):

Select proxies to be used by your crawler. When enabled, these proxies are used from the first pass onwards; RESIDENTIAL is still added as an automatic fallback if they get blocked.

## Actor input object example

```json
{
  "searchQueries": [],
  "includeShowcaseEvent": true,
  "categoryIds": [],
  "startUrls": [],
  "startDate": "",
  "endDate": "",
  "countryCode": "US",
  "region": "200",
  "includeEventDetails": true,
  "maxItems": 100,
  "maxRequestRetries": 3,
  "maxConcurrency": 6,
  "requestHandlerTimeoutSecs": 60,
  "autoProxyOnBlock": true,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "maxItems": 100,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "maxItems": 100,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/ticketmaster-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 '{
  "maxItems": 100,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/ticketmaster-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/ticketmaster-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/n8gslL67i5DYOQabw/builds/001TxlK61Mi71AlFg/openapi.json