# Bandsintown Scraper — Concerts, Tour Dates, Artists & Tickets (`aitorsm/bandsintown-events`) Actor

Scrape upcoming concerts and gigs from Bandsintown by city: artist, venue, date/time, ticket links, RSVP counts, free/streaming flags and event URLs. Clean JSON/CSV, reliable even where other scrapers get blocked — for tour managers, ticketing, music marketing, and event apps.

- **URL**: https://apify.com/aitorsm/bandsintown-events.md
- **Developed by:** [Aitor Sanchez-Mansilla](https://apify.com/aitorsm) (community)
- **Categories:** Automation, Developer tools, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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

## Bandsintown Events Scraper — City-Wide Concert Discovery with Venue + Artist + RSVP Data

[![Bandsintown Events Scraper status](https://apify.com/actor-badge?actor=aitorsm/bandsintown-events)](https://apify.com/aitorsm/bandsintown-events)

The **Bandsintown Events Scraper** is a source of structured **concert data** for live music events and artist tour data from [Bandsintown](https://www.bandsintown.com) — it returns every upcoming concert for a city in one run. Each event returns:

- Event ID + Bandsintown event URL
- Artist name + Bandsintown artist profile URL
- Venue name + start time + timezone
- **RSVP count** — Bandsintown's primary popularity signal (74M users tracking 565K artists)
- Ticket availability flag + off-platform ticket purchase URL
- Free / streaming / promoted-listing flags
- Event image URL

### Why this scraper

Most Bandsintown tools on the market are **artist-centric** — you supply one artist name at a time and get their tour. This actor flips the model: **one city returns every upcoming concert in that city** (typically 40-80 events per run). Useful when you want to:

- Map a city's full concert calendar without iterating through artists
- Discover venues actively programming live music
- Surface ticket-purchase URLs across promoters (Bandsintown links out to Ticketmaster, AXS, Eventbrite, DICE, See Tickets, etc.)
- Get RSVP signals (Bandsintown's "tracking" count is a leading indicator of demand)

### Use Cases

#### 1. **Venue + Promoter Lead Generation**
Bandsintown city pages list events at concrete venues, with ticket links pointing to whoever sells the tickets (Ticketmaster, AXS, EB, DICE, etc.). Cross-reference the ticket-URL domain to surface which venues are locked into which ticketing platform — direct input for ticketing-platform BD targeting.

#### 2. **Concert + Tour Market Intelligence**
Track which artists are playing which venues at what RSVP demand levels. Useful for talent agencies, label A&R, music-marketing SaaS, and tour-routing analytics.

#### 3. **City-Level Music-Scene Health Tracking**
Run the scraper weekly per city and diff: which venues are seeing rising RSVP counts? Which acts are filling rooms? Strong signal for music journalists, tourism boards, and music-industry research.

#### 4. **Cross-Platform Concert Aggregation**
Combine Bandsintown output with Resident Advisor, DICE, Songkick, and Eventbrite datasets for a unified "every paid music event in the city" feed. Bandsintown's coverage is broadest for mainstream concerts; the others fill in club/electronic/indie niches.

#### 5. **Ticket-Marketplace Competitive Tracking**
The `ticketUrl` field exposes the off-platform ticketing partner for each event. Aggregate over many cities to track Ticketmaster vs AXS vs SeatGeek vs indie ticketers share of voice on Bandsintown.

#### 6. **Streaming-Era Tour Strategy**
The `streamingEvent` flag separates virtual events from physical ones. Useful for music-streaming platforms tracking live-events strategy.

> **On the roadmap**: per-artist mode (artist name → full tour), date-range filtering, per-event detail enrichment (artist socials, additional lineup info). [Drop me a line](mailto:business@aitorsm.com) if any of these would unblock a use case.

### Cost

This Actor uses **pay-per-event** pricing — you pay only for events actually scraped. Apify's platform costs are included, so the total amount is predictable.

### Input

- **`citySlug`** *(required)* — the Bandsintown city URL slug (the path component after `/c/`). Find at bandsintown.com → any city page → URL.
  - Examples: `los-angeles-ca`, `new-york-ny`, `chicago-il`, `london-uk`, `berlin-germany`, `paris-france`, `tokyo-japan`, `mexico-city`, `barcelona-spain`.
- **`maxItems`** — cap on events returned. 0 = uncapped. A typical Bandsintown city page embeds 40-80 unique events.

#### Sample input

```json
{ "citySlug": "los-angeles-ca", "maxItems": 50 }
````

### Output

The data is returned in **JSON format**, ideal for direct ingestion into analytics platforms, CRMs, dashboards, or downstream pipelines.

#### Example entry

```json
{
  "eventId": "1036940867",
  "eventUrl": "https://www.bandsintown.com/e/1036940867-iron-maiden-at-bmo-stadium",
  "artistName": "Iron Maiden",
  "artistUrl": "https://www.bandsintown.com/a/1301-iron-maiden",
  "venueName": "BMO Stadium",
  "startsAt": "2026-09-25T18:15:00",
  "timezone": "America/Los_Angeles",
  "rsvpCount": 904,
  "hasTickets": true,
  "isFree": false,
  "promoted": true,
  "streamingEvent": false,
  "ticketUrl": "https://www.bandsintown.com/e/1036940867-iron-maiden-at-bmo-stadium",
  "imageUrl": "https://media.bandsintown.com/300x300/22808209.webp",
  "scrapedFromCitySlug": "los-angeles-ca",
  "scrapedAt": "2026-05-23T02:44:40.979Z"
}
```

#### Fields

| Field | Purpose |
|---|---|
| `eventId`, `eventUrl` | Bandsintown event identifiers + canonical URL |
| `artistName`, `artistUrl` | Primary act for the event + their Bandsintown profile |
| `venueName`, `startsAt`, `timezone` | Venue + start (local ISO + IANA timezone) |
| `rsvpCount` | Bandsintown "I'm going" count (popularity signal) |
| `hasTickets`, `isFree`, `streamingEvent` | Availability + event-type flags |
| `promoted` | True for paid-placement listings (Bandsintown's sponsored slots) |
| `ticketUrl` | Off-platform ticket purchase URL (Ticketmaster / AXS / EB / DICE / etc.) |
| `imageUrl` | Event/artist image |
| `scrapedFromCitySlug`, `scrapedAt` | Audit metadata |

#### Simplified Overview

A simplified view of this data is shown directly in the **Apify console**:

```json
{
  "artistName": "Iron Maiden",
  "imageUrl": "https://media.bandsintown.com/300x300/22808209.webp",
  "startsAt": "2026-09-25T18:15:00",
  "venueName": "BMO Stadium",
  "rsvpCount": 904,
  "hasTickets": true,
  "isFree": false,
  "ticketUrl": "https://www.bandsintown.com/...",
  "eventUrl": "https://www.bandsintown.com/e/1036940867-..."
}
```

***

### How to Use

1. **Find the city slug** — visit bandsintown.com, navigate to your target city, copy the `/c/<slug>` from the URL.
2. **Set `maxItems`** — leave at 0/blank to grab everything (~40-80/city), or cap for previews.
3. **Run the Actor** — typical run time is ~10-15 seconds per city.
4. **Export the dataset** — JSON, CSV, Excel, or HTML.

***

Start scraping Bandsintown concerts today by running this Actor on Apify.

### FAQ

**What does this Actor return?**
Structured concert data for a city: every upcoming live-music event with its artist, venue, start time, RSVP demand signal, and the off-platform ticket-purchase URL. One row per event, ~40-80 per city.

**Is this artist tour data or city data?**
Both angles are covered from a city run — each event names its artist + links their profile, so a city sweep doubles as a snapshot of which artists are touring through that market.

**Can I combine it with other concert sources?**
Yes. Bandsintown's coverage is broadest for mainstream concerts; the music siblings below fill in club, electronic, and indie niches. Shared event/venue/date fields make deduplication straightforward.

**Is there a Bandsintown API — why use this instead?**
Bandsintown's public API is artist-keyed and partner-gated — you authenticate per app, query one artist at a time, and many event fields (venue detail, RSVP demand, ticket URLs) aren't exposed. This Actor returns the full structured record for every event, organized by city rather than by artist, with no API key or quota to manage: point it at a market and export.

### Related Actors

Build a cross-platform live-music and event-data pipeline by combining Bandsintown with these:

- [Songkick](https://apify.com/aitorsm/songkick-events) — concert data with full lineups, venues, and tour dates.
- [Resident Advisor](https://apify.com/aitorsm/ra-events) — electronic music events, club nights, and festival listings.
- [DICE](https://apify.com/aitorsm/dice-events) — concert and venue data with ticketing signals.
- [Eventbrite](https://apify.com/aitorsm/eventbrite) — broad event data and organizer listings across every category.
- [Luma Events](https://apify.com/aitorsm/luma-events) — tech, startup, and community event data.
- [Email Extractor](https://apify.com/aitorsm/email-extractor) — turn venue or promoter websites into emails and phone numbers.

### Contact

- **Email**: <business@aitorsm.com> — for custom features, advanced filtering, tailored data products, or anything off-spec.
- **Apify Discord**: find me as `aitor.sm`.

If this actor has been useful to you, please consider adding it to your bookmarks 📑 on Apify.

# Actor input Schema

## `citySlug` (type: `string`):

Bandsintown URL slug. Find it at bandsintown.com → city → URL after /c/ (e.g. "los-angeles-ca", "london-uk", "berlin-germany", "new-york-ny").

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

Maximum events to return. 0 = uncapped (the city page typically embeds ~40-80 unique events).

## Actor input object example

```json
{
  "citySlug": "los-angeles-ca",
  "maxItems": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "citySlug": "los-angeles-ca",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("aitorsm/bandsintown-events").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 = {
    "citySlug": "los-angeles-ca",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("aitorsm/bandsintown-events").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 '{
  "citySlug": "los-angeles-ca",
  "maxItems": 50
}' |
apify call aitorsm/bandsintown-events --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandsintown Scraper — Concerts, Tour Dates, Artists & Tickets",
        "description": "Scrape upcoming concerts and gigs from Bandsintown by city: artist, venue, date/time, ticket links, RSVP counts, free/streaming flags and event URLs. Clean JSON/CSV, reliable even where other scrapers get blocked — for tour managers, ticketing, music marketing, and event apps.",
        "version": "0.1",
        "x-build-id": "KctrGVePNwHand7A6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aitorsm~bandsintown-events/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aitorsm-bandsintown-events",
                "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/aitorsm~bandsintown-events/runs": {
            "post": {
                "operationId": "runs-sync-aitorsm-bandsintown-events",
                "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/aitorsm~bandsintown-events/run-sync": {
            "post": {
                "operationId": "run-sync-aitorsm-bandsintown-events",
                "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": [
                    "citySlug"
                ],
                "properties": {
                    "citySlug": {
                        "title": "City slug",
                        "type": "string",
                        "description": "Bandsintown URL slug. Find it at bandsintown.com → city → URL after /c/ (e.g. \"los-angeles-ca\", \"london-uk\", \"berlin-germany\", \"new-york-ny\")."
                    },
                    "maxItems": {
                        "title": "Max events",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum events to return. 0 = uncapped (the city page typically embeds ~40-80 unique events).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```