# Bandsintown Events Scraper (`automation-lab/bandsintown-events-scraper`) Actor

Extract public Bandsintown concert dates, tour history, artist profiles, venues, lineups, coordinates, and ticket offers by artist name, ID, or URL.

- **URL**: https://apify.com/automation-lab/bandsintown-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other, Travel
- **Stats:** 1 total users, 0 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.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Extract public Bandsintown concert dates, tour history, venues, artist profiles, lineups, coordinates, and ticket offers into a clean Apify dataset.

Use an artist name, numeric Bandsintown ID, or profile URL. Choose upcoming shows, past concerts, every available event, or a custom date range. No Bandsintown login or API key is required.

### What does Bandsintown Events Scraper do?

This Actor turns artist-centric Bandsintown pages into structured records.

- 🎤 Resolve artists by name, ID, or URL.
- 📅 Collect upcoming or historical concert dates.
- 🏟️ Capture venue, city, region, and country.
- 🎟️ Optionally enrich ticket offers and availability.
- 🗺️ Optionally extract venue latitude and longitude.
- 👥 Preserve full event lineups when exposed.
- 📈 Export follower counts and verified status.
- 🔁 Deduplicate the same event across queried artists.

The default output is a table that can be downloaded as JSON, CSV, Excel, XML, or RSS.

### Who is it for?

#### Event aggregators

Build concert calendars and refresh announced dates on a schedule.

#### Ticketing and resale teams

Monitor ticket links, offer availability, and on-sale information.

#### Music marketers

Track tours for a roster of artists and identify active markets.

#### Venue analysts

Create venue inventories and compare tour routing by city or country.

#### Artist and label teams

Monitor public follower counts, verified profiles, and concert history.

#### Data engineers

Feed normalized concert records into warehouses, dashboards, and alerting pipelines.

### Why use this Actor?

Bandsintown pages are protected by Cloudflare and direct HTTP requests are commonly blocked. This Actor uses conservative residential browser sessions, blocks unnecessary media, retries bounded failures, and extracts server-rendered public data.

You receive:

- consistent field names across artists;
- a global event limit for predictable runs;
- partial success when one artist fails;
- source URLs for verification;
- timestamps for monitoring workflows;
- separate event and artist dataset views.

### Quick start

1. Open the Actor input page.
2. Add one or more artist names, IDs, or profile URLs.
3. Choose the records to return.
4. Select an event date scope.
5. Set a reasonable maximum event count.
6. Enable event detail enrichment only when needed.
7. Start the run and open the dataset.

A low-cost first run:

```json
{
  "artists": ["Coldplay"],
  "queryType": "events",
  "dateFilter": "past",
  "includeEventDetails": false,
  "maxResults": 10
}
```

### Input reference

| Field | Type | Default | Purpose |
|---|---|---:|---|
| `artists` | string\[] | `Coldplay` | Artist names, numeric IDs, or profile URLs |
| `queryType` | string | `events` | Return events, artists, or both |
| `dateFilter` | string | `past` | Upcoming, past, all, or custom dates |
| `dateFrom` | date | empty | Inclusive custom range start |
| `dateTo` | date | empty | Inclusive custom range end |
| `includeEventDetails` | boolean | `false` | Add geo, lineup, descriptions, and offers |
| `maxResults` | integer | `10` | Global cap for event rows |
| `proxyConfiguration` | object | residential | Connection settings |

Artist profile rows do not consume the event limit.

### Artist input formats

Use any of these values in the `artists` list:

```text
Coldplay
99
https://www.bandsintown.com/a/99-coldplay
```

Names use Bandsintown's public artist route. IDs are the least ambiguous choice when different artists share a name.

### Event date filters

#### Upcoming

Returns currently announced future events from the artist page.

#### Past

Returns historical concerts and follows public historical pages while the result cap requires more records.

#### All

Combines available upcoming and historical events.

#### Custom

Applies inclusive `dateFrom` and `dateTo` bounds. At least one bound is required.

```json
{
  "artists": ["Coldplay"],
  "queryType": "events",
  "dateFilter": "custom",
  "dateFrom": "2024-01-01",
  "dateTo": "2025-12-31",
  "maxResults": 200
}
```

### Event detail enrichment

Set `includeEventDetails` to `true` when you need deeper fields.

The Actor opens each event page and looks for public `MusicEvent` structured data. Depending on the event, enrichment can add:

- venue coordinates;
- complete lineup;
- event description;
- end datetime;
- ticket offer URLs;
- availability status;
- price and currency;
- on-sale datetime.

Enrichment requires one additional page load per event. Leave it off for fast roster monitoring.

### Output data

The default dataset contains two typed record shapes.

#### Event fields

| Field | Description |
|---|---|
| `recordType` | Always `event` |
| `id` | Bandsintown event ID |
| `title` | Event or billing title |
| `url` | Canonical public event URL |
| `datetime` | Local ISO event start |
| `endDatetime` | Optional event end |
| `timezone` | Venue timezone when available |
| `artistId` | Queried artist ID |
| `artistName` | Queried artist name |
| `venueName` | Venue name |
| `venueCity` | City |
| `venueRegion` | State or region |
| `venueCountry` | Country |
| `venueLatitude` | Optional latitude |
| `venueLongitude` | Optional longitude |
| `lineup` | Optional performer names |
| `offers` | Optional ticket offer objects |
| `streamingEvent` | Whether the listing is a stream |
| `scrapedAt` | UTC extraction time |

#### Artist fields

| Field | Description |
|---|---|
| `recordType` | Always `artist` |
| `id` | Bandsintown artist ID |
| `name` | Artist name |
| `url` | Canonical profile URL |
| `imageUrl` | Public profile image |
| `followerCount` | Public Bandsintown followers |
| `upcomingEventCount` | Upcoming events visible in the page payload |
| `verified` | Verified profile flag |
| `genre` | Public genre label |
| `hometown` | Public hometown label |
| `scrapedAt` | UTC extraction time |

### Example event record

```json
{
  "recordType": "event",
  "id": "1036391781",
  "title": "Coldplay at Wembley Stadium",
  "url": "https://www.bandsintown.com/e/1036391781",
  "datetime": "2025-09-12T16:45:00",
  "timezone": "Europe/London",
  "artistId": "99",
  "artistName": "Coldplay",
  "venueName": "Wembley Stadium",
  "venueCity": "London",
  "venueCountry": "United Kingdom",
  "streamingEvent": false,
  "scrapedAt": "2026-07-13T06:38:13.530Z"
}
```

Fields not exposed by a page are omitted instead of filled with misleading null values.

### Example artist record

```json
{
  "recordType": "artist",
  "id": "99",
  "name": "Coldplay",
  "url": "https://www.bandsintown.com/a/99",
  "followerCount": 8919492,
  "upcomingEventCount": 0,
  "verified": true,
  "genre": "Alternative, Rock",
  "hometown": "London, United Kingdom",
  "scrapedAt": "2026-07-13T06:38:13.530Z"
}
```

### How much does it cost to scrape Bandsintown events?

The Actor uses pay-per-event pricing: **$0.075 per run** plus one result event for each dataset row. The BRONZE result price is **$0.0017186 per record** (about $1.72 per 1,000 rows), with canonical loyalty-tier discounts from FREE through DIAMOND.

The start charge covers fixed browser startup and residential proxy warmup so even tiny runs remain sustainable. Browser and proxy work is paid by the Actor owner under PPE, not billed separately to the user. The live Apify pricing panel is authoritative.

Control cost by:

- keeping `maxResults` low for initial runs;
- disabling detail enrichment when base event fields are enough;
- batching several artists into one run;
- using artist IDs to avoid ambiguous resolution.

### Roster monitoring workflow

Run a list of managed artists daily:

```json
{
  "artists": ["99", "Metallica", "System of a Down"],
  "queryType": "both",
  "dateFilter": "upcoming",
  "includeEventDetails": false,
  "maxResults": 500
}
```

Store event IDs in your database. On each run, compare new IDs and changed ticket fields to trigger announcements.

### Tour history analysis workflow

Use `past` or `custom` mode to build a historical table. Group events by year, country, city, or venue. Join follower snapshots from artist records to enrich reporting.

For large artists, start with a narrow date range and a moderate cap before requesting the full archive.

### Venue and ticket intelligence workflow

Enable detail enrichment for the subset of events that needs geographic or offer data. Send coordinates to a mapping tool, group venues by market, and retain source URLs for analyst verification.

Ticket availability changes over time. Schedule recurring runs rather than treating one extraction as permanent truth.

### Integrations

#### Google Sheets

Export the dataset to a sheet for editorial calendars and tour planning.

#### Zapier and Make

Trigger notifications when a scheduled run finishes and route new event rows into CRM or messaging tools.

#### n8n

Compare event IDs with a previous dataset and notify teams about newly announced concerts.

#### Webhooks

Attach an Actor run webhook to start downstream ETL as soon as extraction completes.

#### Data warehouses

Use the Apify API to ingest JSON into BigQuery, Snowflake, PostgreSQL, or object storage.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bandsintown-events-scraper').call({
  artists: ['Coldplay', 'Metallica'],
  queryType: 'events',
  dateFilter: 'upcoming',
  maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/bandsintown-events-scraper').call(run_input={
    'artists': ['Coldplay'],
    'queryType': 'both',
    'dateFilter': 'past',
    'maxResults': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~bandsintown-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"artists":["Coldplay"],"queryType":"events","dateFilter":"past","maxResults":25}'
```

Fetch dataset items after the run succeeds using its `defaultDatasetId`.

### Use with Apify MCP

Connect AI assistants through the actor-specific Apify MCP endpoint:

```text
https://mcp.apify.com?tools=automation-lab/bandsintown-events-scraper
```

#### Claude Code

Run this command in your terminal:

```bash
claude mcp add --transport http apify-bandsintown 'https://mcp.apify.com?tools=automation-lab/bandsintown-events-scraper'
```

#### Claude Desktop

Add this entry to your Claude Desktop MCP configuration. The `mcp-remote` adapter connects Desktop's local MCP client to the remote HTTP endpoint:

```json
{
  "mcpServers": {
    "apify-bandsintown": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com?tools=automation-lab/bandsintown-events-scraper"
      ]
    }
  }
}
```

Restart Claude Desktop after saving the configuration.

#### Cursor

Save this as `.cursor/mcp.json` in your project, or merge the server entry into your existing file:

```json
{
  "mcpServers": {
    "apify-bandsintown": {
      "url": "https://mcp.apify.com?tools=automation-lab/bandsintown-events-scraper"
    }
  }
}
```

#### VS Code

Save this as `.vscode/mcp.json`, then start the server from VS Code's MCP servers view:

```json
{
  "servers": {
    "apify-bandsintown": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/bandsintown-events-scraper"
    }
  }
}
```

#### Example prompts

- “Extract upcoming events for my artist roster and group them by country.”
- “Build a venue table from Coldplay's 2024–2025 concert history.”
- “Find ticket links for these public concert dates.”
- “Create a venue map from enriched event records.”

### Tips for reliable results

- Prefer numeric IDs for artists with ambiguous names.
- Keep the residential proxy setting enabled.
- Start with 10–50 events before scaling.
- Enrich only when coordinates or ticket objects are needed.
- Use source URLs to verify time-sensitive ticket information.
- Schedule monitoring runs at a considerate frequency.
- Remember that a profile can legitimately have no upcoming dates.

### Troubleshooting

#### Why did an artist return no records?

Check the spelling or use the numeric artist ID. A profile can also be unavailable, blocked for the current session, or have no events in the selected date range.

#### Why are lineup or coordinates missing?

Enable `includeEventDetails`. Even then, Bandsintown may not expose every optional field for every listing.

#### Why is the run slower with enrichment?

Each event detail requires another browser request through a residential proxy. Disable enrichment for fast event-list monitoring.

#### Why does direct HTTP return 403?

Bandsintown uses Cloudflare. The Actor intentionally uses browser sessions and residential proxy rotation rather than direct HTTP extraction.

### Data quality notes

Bandsintown is the source of record for the extracted public page fields. Event titles, times, venue spellings, ticket offers, and follower counts can change after extraction.

The Actor deduplicates by Bandsintown event ID. The same event queried through multiple lineup artists is saved once per run.

Local event times are preserved as supplied, together with timezone when available.

### Responsible use and legality

This Actor extracts publicly visible event and artist information. Public availability does not remove your obligations.

You are responsible for:

- complying with applicable law;
- following Bandsintown's terms and policies;
- respecting intellectual property rights;
- using considerate run frequency;
- avoiding spam or harmful profiling;
- securing exported datasets;
- honoring deletion or correction obligations.

This Actor does not access private accounts, user credentials, or private fan data.

### FAQ

#### Does it require a Bandsintown API key?

No. It extracts public web pages.

#### Can I provide artist names and IDs together?

Yes. Mix names, numeric IDs, and URLs in the same list.

#### Can it scrape historical concerts?

Yes. Choose `past`, `all`, or a custom date range.

#### Can it return artist profiles without events?

Yes. Set `queryType` to `artists`.

#### Does the event limit include artist rows?

No. `maxResults` limits event rows only.

#### Does it support ticket prices?

When public event structured data exposes price and currency, detail enrichment preserves them in `offers`.

#### Can I export to CSV or Excel?

Yes. Use Apify dataset export formats.

#### Can I schedule recurring runs?

Yes. Use Apify schedules and webhooks.

### Related scrapers

Combine this Actor with other automation-lab Store tools when your workflow needs broader event or lead data:

- [AllEvents Scraper](https://apify.com/automation-lab/allevents-scraper) for cross-category public events.
- [Eventbrite Events Scraper](https://apify.com/automation-lab/eventbrite-events-scraper) for organizer and Eventbrite listing workflows.
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for venue and local-business enrichment.

### Support

If a valid public artist page repeatedly fails, open an Actor issue with:

- the exact artist input;
- selected date filter;
- whether enrichment was enabled;
- the run URL;
- the approximate time of failure.

Do not include private credentials or confidential data.

### Start scraping Bandsintown

Add an artist, choose a date scope, keep the first result cap small, and run the Actor. Scale the same input after you verify the event and artist fields fit your workflow.

# Actor input Schema

## `artists` (type: `array`):

Enter artist names, numeric Bandsintown artist IDs, or full Bandsintown artist URLs, one per line.

## `queryType` (type: `string`):

Return concert events, artist profiles, or both record types.

## `dateFilter` (type: `string`):

Choose upcoming events, past concerts, all dates, or a custom inclusive date range.

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

Optional first event date (YYYY-MM-DD), used when Event date scope is Custom.

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

Optional last event date (YYYY-MM-DD), used when Event date scope is Custom.

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

Open each event page to add coordinates, full lineup, descriptions, and structured ticket offers. Slower and more proxy intensive.

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

Global event limit across all artists. Artist profile rows do not count toward this limit.

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

Bandsintown blocks direct traffic. Residential Apify Proxy is preselected for reliable access.

## Actor input object example

```json
{
  "artists": [
    "Coldplay"
  ],
  "queryType": "events",
  "dateFilter": "past",
  "includeEventDetails": false,
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "groups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}
```

# Actor output Schema

## `events` (type: `string`):

Events with dates, venues, locations, lineup and ticket data.

## `artists` (type: `string`):

Artist IDs, follower counts, verification status and profile links.

# 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 = {
    "artists": [
        "Coldplay"
    ],
    "queryType": "events",
    "dateFilter": "past",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "groups": [
            "RESIDENTIAL"
        ],
        "countryCode": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bandsintown-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 = {
    "artists": ["Coldplay"],
    "queryType": "events",
    "dateFilter": "past",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "groups": ["RESIDENTIAL"],
        "countryCode": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bandsintown-events-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 '{
  "artists": [
    "Coldplay"
  ],
  "queryType": "events",
  "dateFilter": "past",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "groups": [
      "RESIDENTIAL"
    ],
    "countryCode": "US"
  }
}' |
apify call automation-lab/bandsintown-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CmspYlexPv2fsQmdd/builds/TklLqDyjtNP3ifcob/openapi.json