# Bandsintown Scraper \[Only $1/1K💰] | Concerts | Tour Dates (`ahmed_jasarevic/bandsintown-scraper`) Actor

Get upcoming and past concert, tour and festival data from Bandsintown as structured JSON — artist, date, venue, city, coordinates, ticket links, lineup and RSVP counts. Search artists, festivals or venues. No API key, no login.

- **URL**: https://apify.com/ahmed_jasarevic/bandsintown-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 $0.90 / 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

## Bandsintown Scraper

Bandsintown Scraper extracts upcoming and past concerts, tour dates, festivals and venue shows from Bandsintown and returns them as one clean row per event — artist, event title, date and time, venue, city/region/country, coordinates, ticket links and, optionally, the full lineup, RSVP count, venue address and ticket vendors.

Search by artist name, tour or festival name, venue name, a Bandsintown URL or a numeric artist ID — every term resolves through Bandsintown's own search, so a single input field covers artists, festivals, venues and single events. No official API key and no browser required.

Built for tour managers, booking agents, promoters, music marketing and fan-analytics teams, ticketing and resale tools, event apps and live-music data pipelines.

### Track Concert Tour Dates, Festival Lineups & Live Music Events

- **Artist tour tracking and tour-date monitoring** — schedule daily runs to catch newly announced dates for a roster or a watchlist of artists.
- **Building a live music event database** — collect concerts, festivals and venue shows into one structured dataset.
- **Festival lineup extraction** — pull a festival's dates, venue and full lineup in a single run.
- **Venue calendars and local concert listings** — scrape every upcoming show at a venue and build a city-level concert calendar.
- **Ticketing and resale intelligence** — capture ticket availability, the primary ticket URL and the ticket vendors for each event.
- **Music marketing and fan analytics** — track artist follower counts and per-event RSVP / fans-interested numbers.

### How It Works

![How the Bandsintown Scraper works: artist, venue and festival searches become structured concert rows with ticket data.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-bandsintown.webp)

The Actor resolves artist, festival, venue and event terms through Bandsintown's public suggestion endpoint, then parses the page-state JSON embedded in each page. Upcoming event pages can be opened for lineup, RSVP and ticket details, and rows are deduplicated by event ID.

Each row covers one event with its artist, date, timezone, venue, location, ticket status and source URL. Use the feed for tour calendars, venue research and ticket-demand tracking.

Bandsintown's consumer site is a server-rendered React app that embeds its whole page state in a `window.__data = { ... }` JSON blob inside the served HTML. The actor parses that blob directly — no browser, no DOM scraping and no official API key:

- **Resolution** → `GET /searchSuggestions?searchTerm=<term>` returns clean JSON with `artists`, `events`, `festivals` and `venues` in one call; the best match wins (exact name > prefix > word > substring). A name that matches both a band and a festival scrapes both.
- **Artist page** (`/a/`) → `window.__data.artistView.body` holds the artist info and all upcoming events; past events come from `events.pastEvents` and paginate through `/a/<id>/past-events?startDate=...`.
- **Festival page** (`/f/`) → `festivalView.body` holds the festival dates, venue, description and the lineup slots.
- **Venue page** (`/v/`) → `initialState.events.eventList` holds every upcoming show at that venue.
- **Event page** (`/e/`) → `window.__data.eventView.body` contains the lineup, RSVP count, venue details, ticket vendors and description. Only **upcoming** events are opened this way; past events are pushed straight from the artist's past-events list.
- Rows are **de-duplicated by event id**, so a show reached through an artist page, a festival lineup and a venue page is written once.

Because Bandsintown sits behind Cloudflare and rejects plain HTTP/1.1 clients, the actor uses Crawlee's `ImpitHttpClient` with the `okhttp5` browser profile, which negotiates HTTP/2 with a fingerprint Cloudflare accepts — so it stays a plain `CheerioCrawler` (no browser) while still getting through.

### Input Parameters

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `artists` | string\[] | Yes | `["Metallica", "Yo-Yo Ma"]` | Search terms: artist names (`Metallica`), tour names, festival names, venue names, Bandsintown URLs (`/a/`, `/f/`, `/v/`, `/e/`) or numeric artist IDs / id-slugs (`99-coldplay`). Each term resolves to the best matching artist, festival, venue or event. |
| `includeEventDetails` | boolean | No | `false` | Open each **upcoming** event page to add lineup, RSVP count, venue address, country and ticket vendors/prices. Slower, uses more requests, and costs one `event-detail` pay-per-event charge per enriched event. Past events are always saved without this fetch. |
| `includePastEvents` | boolean | No | `false` | Also scrape past concerts of matched artists (paginated as far back as Bandsintown allows). Past shows fill the remaining `maxEventsPerArtist` budget after upcoming shows. |
| `maxEventsPerArtist` | integer | No | `50` | Maximum events per search term (upcoming first, past after). Range `1`–`500`. |
| `maxArtists` | integer | No | `10` | Maximum search terms per run. Range `1`–`100`. |
| `proxy` | object (proxy) | No | Apify Proxy off | Standard Apify proxy configuration. Not required — the actor reads Bandsintown's own JSON. |

### Output Fields

Each dataset item is one event.

| Field | Type | Description |
|-------|------|-------------|
| `matchType` | string | How the term matched: `artist`, `festival`, `venue` or `event`. |
| `searchTerm` | string | The input term that produced the row. |
| `eventStatus` | string | `upcoming` or `past`. |
| `artist` | string | Artist name. |
| `artistId` | number or null | Bandsintown artist id. |
| `artistUrl` | string or null | Bandsintown artist page URL. |
| `artistFollowers` | number or null | Number of Bandsintown followers. |
| `artistFollowersText` | string or null | Follower count as displayed, e.g. `"7.22M Followers"`. |
| `artistVerified` | boolean | Whether the artist is verified on Bandsintown. |
| `artistImageUrl` | string or null | Artist image URL. |
| `artistUpcomingShows` | number or null | Number of upcoming shows listed for the artist. |
| `eventId` | string | Bandsintown event id. |
| `eventTitle` | string | Event title (falls back to `"<artist> at <venue>"` when Bandsintown has none). |
| `eventUrl` | string | Bandsintown event page URL. |
| `startsAt` | string | Event start date/time, local to the event timezone (ISO 8601). |
| `endsAt` | string or null | Event end date/time, when available. |
| `timezone` | string or null | IANA timezone of the event. |
| `venueName` | string or null | Venue name. |
| `location` | string or null | Raw location string as shown by Bandsintown, e.g. `"Las Vegas, NV"`. |
| `city` | string or null | City. |
| `region` | string or null | Region / state code. |
| `country` | string or null | Country. |
| `venueAddress` | string or null | Full venue street address (event-details mode). |
| `venueId` | number or null | Bandsintown venue id (event-details mode). |
| `latitude` | number or null | Venue latitude. |
| `longitude` | number or null | Venue longitude. |
| `hasTickets` | boolean | Whether tickets are available. |
| `isFree` | boolean | Whether the event is free. |
| `streamingEvent` | boolean | Whether the event is a livestream. |
| `ticketUrl` | string or null | Primary ticket / call-to-action URL. |
| `ticketVendors` | string\[] | Ticket vendor domains (event-details mode). |
| `ticketPriceTiers` | object\[] | Ticket price tiers with `vendor`, `price`, `formattedPrice` and `currency` (event-details mode; prices are often hidden by Bandsintown). |
| `lineup` | string\[] | Lineup artist names (event-details mode; always populated for festival rows). |
| `lineupDetails` | object\[] | Lineup artists with `name`, `id`, `followersText` and `url` (event-details mode). |
| `rsvpCount` | number or null | Number of fans interested / RSVPs (event-details mode). |
| `fansInterestedText` | string or null | Fans-interested text as displayed (event-details mode). |
| `description` | string or null | Event description (event-details mode). |
| `scrapedAt` | string | ISO timestamp of when the row was scraped. |

### Example Input

```json
{
  "artists": ["Metallica", "Coachella", "Madison Square Garden", "99-coldplay"],
  "includeEventDetails": true,
  "includePastEvents": true,
  "maxEventsPerArtist": 20,
  "maxArtists": 5
}
```

The smallest input that produces results:

```json
{
  "artists": ["Metallica"]
}
```

### Example Output

```json
{
  "matchType": "artist",
  "searchTerm": "Metallica",
  "eventStatus": "upcoming",
  "artist": "Metallica",
  "artistId": 438314,
  "artistUrl": "https://www.bandsintown.com/a/438314",
  "artistFollowers": 7220000,
  "artistFollowersText": "7.22M Followers",
  "artistVerified": true,
  "artistImageUrl": "https://photos.bandsintown.com/thumb/1234567.jpeg",
  "artistUpcomingShows": 42,
  "eventId": "13722599",
  "eventTitle": "Metallica at Moody Center",
  "eventUrl": "https://www.bandsintown.com/e/13722599",
  "startsAt": "2027-05-14T20:00:00",
  "endsAt": null,
  "timezone": "America/Chicago",
  "venueName": "Moody Center",
  "location": "Austin, TX",
  "city": "Austin",
  "region": "TX",
  "country": "United States",
  "venueAddress": "2001 Robert Dedman Dr, Austin, TX 78712",
  "venueId": 885936,
  "latitude": 30.2826,
  "longitude": -97.7323,
  "hasTickets": true,
  "isFree": false,
  "streamingEvent": false,
  "ticketUrl": "https://www.bandsintown.com/e/13722599/buy_tickets",
  "ticketVendors": ["ticketmaster.com"],
  "ticketPriceTiers": [
    { "vendor": "ticketmaster.com", "price": null, "formattedPrice": null, "currency": "USD" }
  ],
  "lineup": ["Metallica", "Pantera"],
  "lineupDetails": [
    { "name": "Pantera", "id": 99123, "followersText": "1.2M Followers", "url": "https://www.bandsintown.com/a/99123" }
  ],
  "rsvpCount": 1820,
  "fansInterestedText": "1.8K Fans Interested",
  "description": "Metallica brings the M72 World Tour to Austin.",
  "scrapedAt": "2026-10-16T09:00:00.000Z"
}
```

### Integrations & Automation

- **Apify API** — start a run programmatically and read results from the default dataset; every run also exposes the dataset as JSON, CSV or Excel.
- **Webhooks** — get notified when a run finishes, then push new events into your own systems.
- **Zapier / Make / n8n** — connect the actor through Apify's no-code integrations to write results to Google Sheets, Airtable, a database or a Slack channel.
- **Scheduling** — for tour-date monitoring, run the actor **daily** against your artists/festivals and diff by `eventId` to surface newly announced dates; run it **weekly** for slower venue-calendar refreshes.

### Related Actors

- [Songkick Concert Calendar Scraper](https://apify.com/abotapi/songkick-concert-calendar-scraper) — the same audience on a second live-music platform; pair Songkick and Bandsintown data to cover more tour dates than either source alone.
- [Eventbrite Scraper — Event & Organizer Data](https://apify.com/aitorsm/eventbrite) — the largest event-data actor in the Store; use it for ticketed events and organizer leads alongside concert/tour data.
- [Ticketmaster Scraper](https://apify.com/ahmed_jasarevic/ticketmaster-scraper) — event and ticket-status data from Ticketmaster, the primary ticketing source many Bandsintown events link out to.
- [SeatGeek Scraper](https://apify.com/ahmed_jasarevic/seatgeek-scraper) — concert and sports ticket price data from SeatGeek for secondary-market pricing.
- [StubHub Scraper](https://apify.com/lulzasaur/stubhub-scraper) — ticket resale listings to complete a live-events pricing and availability pipeline.

### Frequently Asked Questions

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

Bandsintown's official REST API (`rest.bandsintown.com`) is read-only and covers artist info plus artist events (`/artists/{artist}/events?app_id=...`, with an optional `date` of `upcoming`, `past`, `all` or a range). It requires an **`app_id` assigned by Bandsintown** — artists can generate a key for their own profile in Bandsintown for Artists, and organizations must agree terms through Bandsintown's partnership program before they get one. It is **artist-scoped**, so venues and festivals are not first-class lookups.

This actor needs **no `app_id` and no approval**. It resolves any term — artist, festival, venue or single event — through Bandsintown's own search, returns one normalized row per event with venue coordinates, and can enrich upcoming events with lineup, RSVP count, venue address and ticket vendors. Use the official API if you are an artist with your own key or have a partnership agreement and only need artist-scoped reads.

#### What are alternatives to this actor or to Bandsintown data?

- **Other Bandsintown scrapers in the Apify Store** — several cover the same public pages; compare on price per result, whether they call Bandsintown's REST API (and therefore need an `app_id`) and how they paginate past events.
- **Songkick** — a second large live-music source (see [Songkick Concert Calendar Scraper](https://apify.com/abotapi/songkick-concert-calendar-scraper)); its public API is licensed separately.
- **Eventbrite** — for ticketed events and organizer profiles ([Eventbrite Scraper](https://apify.com/aitorsm/eventbrite)).
- **Licensed datasets** — JamBase Data (B2B licensed) and Pollstar (licenses its historical archive) sell normalized live-music data commercially.
- **The official Bandsintown API** — best when you hold your own `app_id` and only need artist-scoped reads.

#### How do I scrape Bandsintown concert and tour dates?

Pass one or more artist, festival or venue names in the `artists` input and run the actor. Each run returns one row per event with the artist, date/time, venue, location and ticket link already parsed — no API key, no login, no browser.

#### Does Bandsintown have a public API?

Bandsintown has a REST API for artist info and artist events, but access requires an `app_id` that Bandsintown assigns (organizations must agree partnership terms first). This actor instead reads Bandsintown's own public pages, so it works without a key or an approval step.

#### How can I get concert tour dates as JSON?

Run the actor and download the dataset as JSON, CSV or Excel from Apify Console, or read it over the Apify API. Each item carries `artist`, `startsAt`, `venueName`, `city`, `region`, `country`, `latitude`, `longitude`, `ticketUrl` and `eventUrl`.

#### How do I monitor newly announced tour dates?

Schedule the actor to run daily against the artists you track, then compare consecutive runs by `eventId` to detect dates that appeared since the previous run. This is the cheapest way to catch new tour announcements.

#### What's the best way to build a live music event database?

Run the actor across a list of artists, festivals and venues, then map the output fields — `eventId`, `artist`, `eventTitle`, `startsAt`, `venueName`, `city`, `country`, `latitude`, `longitude` — into your schema. Rows are already de-duplicated by `eventId`, so overlapping searches do not create duplicate entries.

#### Can I get festival lineups from Bandsintown?

Yes. Festival rows always include the lineup, and setting `includeEventDetails` to `true` adds the lineup, RSVP count, venue address and ticket vendors for upcoming events as well.

### For AI Agents & LLM Apps

**Purpose:** return one row per Bandsintown event (upcoming or past) for a list of search terms — artist, festival, venue or event — with date/time, venue, location, coordinates and ticket links, plus optional lineup/RSVP enrichment.

**Minimal working input:**

```json
{ "artists": ["Metallica"] }
```

**Enriched variant (lineup, RSVP count, venue address, ticket vendors):**

```json
{ "artists": ["Coachella", "Madison Square Garden"], "includeEventDetails": true, "maxEventsPerArtist": 100, "maxArtists": 5 }
```

**Past events variant:**

```json
{ "artists": ["Radiohead"], "includePastEvents": true, "maxEventsPerArtist": 200 }
```

**Output fields:** `matchType`, `searchTerm`, `eventStatus`, `artist`, `artistId`, `artistUrl`, `artistFollowers`, `artistFollowersText`, `artistVerified`, `artistImageUrl`, `artistUpcomingShows`, `eventId`, `eventTitle`, `eventUrl`, `startsAt`, `endsAt`, `timezone`, `venueName`, `location`, `city`, `region`, `country`, `venueAddress`, `venueId`, `latitude`, `longitude`, `hasTickets`, `isFree`, `streamingEvent`, `ticketUrl`, `ticketVendors`, `ticketPriceTiers`, `lineup`, `lineupDetails`, `rsvpCount`, `fansInterestedText`, `description`, `scrapedAt`.

**Behaviors an agent should know:**

- `artists` is required — an empty list produces no output.
- `maxArtists` caps how many search terms are processed (default `10`, max `100`); `maxEventsPerArtist` caps events per term (default `50`, max `500`).
- **Free (non-paying) runs are hard-capped at 10 events.** Only paying runs return the full `maxEventsPerArtist` per term.
- `includeEventDetails: true` adds one extra request per **upcoming** event and, with pay-per-event pricing, one `event-detail` charge per enriched event. **Past events are never enriched.**
- Rows are de-duplicated by `eventId`, so overlapping search terms do not create duplicate rows.
- `ticketPriceTiers[].price` is frequently `null` — Bandsintown usually hides public prices; `ticketVendors` and `ticketUrl` are still returned.

**Billing:** pay-per-result — **$1 per 1,000 dataset items** ($0.001 each), plus **$2.50 per 1,000 `event-detail` enrichments** ($0.0025 each) when `includeEventDetails` is on, plus a small per-run start fee. Budget from expected events + enriched events.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by or sponsored by Bandsintown**.

It accesses only the **publicly available** Bandsintown pages that are served to any anonymous visitor; it does not log in, bypass authentication, solve CAPTCHAs or access non-public data.

You are responsible for ensuring your use complies with Bandsintown's terms of service and with applicable law. The output contains public event, artist and venue information — no personal contact data — and `ticketUrl` / `ticketVendors` point to third-party ticketing sites whose own terms apply.

### SEO Keywords

bandsintown scraper, bandsintown api, bandsintown api alternative, scrape bandsintown, concert data api, tour dates api, live music data, concert scraper, tour date tracking, festival lineup scraper, artist tour monitoring, venue concert calendar, upcoming concerts data, concert ticket links, live music events dataset, bandsintown events to json, concert data export csv, music industry data, artist follower data, event rsvp data, songkick alternative, pollstar alternative, tour announcement monitoring, live music analytics, concert listings scraper

# Actor input Schema

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

Search terms: artist names, tour names, festival names, venue names, Bandsintown URLs (artist /a/, festival /f/, venue /v/, event /e/) or numeric artist IDs. Every term is resolved through Bandsintown's own search to the best matching artist, festival, venue or event, and its events are scraped.

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

Also open each upcoming event page to extract the full lineup, RSVP / fans-interested count, venue address, country and ticket vendors + price tiers (when shown). Slower, uses more requests and - when pay-per-event pricing is enabled - costs one "event-detail" charge per enriched event. Past events are always saved without this extra fetch.

## `includePastEvents` (type: `boolean`):

Also scrape past concerts of matched artists (Bandsintown keeps up to 50 per page and paginates further back). Past shows fill the remaining "Max events per artist" budget after upcoming shows.

## `maxEventsPerArtist` (type: `integer`):

Maximum number of events to extract per search term (upcoming first, then past events when enabled).

## `maxArtists` (type: `integer`):

Maximum number of search terms to process per run.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "artists": [
    "Metallica",
    "Yo-Yo Ma"
  ],
  "includeEventDetails": false,
  "includePastEvents": false,
  "maxEventsPerArtist": 50,
  "maxArtists": 10,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "artists": [
        "Metallica",
        "Yo-Yo Ma"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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