# Concert Archives Scraper - Concerts, Tours, Venues & Setlists (`abotapi/concert-archives-scraper`) Actor

Scrape Concert Archives concert and tour history: past and upcoming dates, venues, cities, line-ups, tours, genres, tickets and setlists. Search by band, venue or location, or paste links. Incremental monitoring with NEW, UPDATED, REAPPEARED, EXPIRED, resume and MCP export.

- **URL**: https://apify.com/abotapi/concert-archives-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Other, Developer tools, Travel
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 92.5% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 concert records

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

## Concert Archives Scraper: Concert History, Tour Dates & Setlists

Concert Archives Scraper turns Concert Archives, the fan-built live-music database, into a clean concert-history API. Search a band, a venue or a city and get its complete concert history: past dates going back decades, upcoming shows, the billed line-up, tours, ticket links and the songs actually played. Search by name or paste links, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Three ways to find a history.** Search by band, venue or city name and the top matching page is walked automatically, or paste any Concert Archives link (band, venue, location, a single concert, a search link or an advanced search link) and skip the lookup entirely.
- **Full history, not just upcoming shows.** A walk follows a band, venue or location's concert table forward to its natural end, from decades-old shows to next month's dates.
- **Concert-level depth on demand.** Fetch each concert's own page for the full billed line-up with genres, the description, the poster image, the ticket seller and link, the event status and the community line-up, attendee and photo counts, only when you switch it on.
- **Setlists included.** Pull the songs actually played, per band, for concerts that have a setlist on the site.
- **Filters that tell you the truth.** Upcoming/past and Year filters apply wherever the site actually supports them, and a run says so out loud in the log rather than quietly handing back an unfiltered result labelled as filtered.
- **Built for monitoring.** Incremental mode returns only new, changed and reappeared concerts on repeat runs, and a blocked run fails loudly instead of returning an empty dataset.
- **No account, no key.** Nothing to sign in with, and the default proxy setting works out of the box.

### Use Cases

- **Fans and ticket buyers:** check exactly when a band last played your city, and where the tour goes next.
- **Promoters and venue bookers:** review a venue's full booking history and genre mix before pitching a show.
- **Music journalists and researchers:** build tour timelines, genre trends and lineup histories for a band or a scene.
- **Setlist and stats trackers:** collect the songs played per show to spot patterns across a tour.
- **Archivists and fan sites:** back up a band's or a venue's concert record outside the site itself.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `kind` | `"concert"` |
| `recordId` / `concertId` | `"00000000"` |
| `url` / `slug` | link to the concert page / `"sample-band--00000000"` |
| `title` | `"Sample Band"` |
| `startDate` / `endDate` | `"2027-01-15"` / `"2027-01-15"` |
| `dateText` | `"Jan 15, 2027"` |
| `isUpcoming` | `true` |
| `eventStatus` | `"scheduled"` (also `"cancelled"`, `"postponed"`, `"rescheduled"`, when details are fetched) |
| `tourName` | `"Sample World Tour"` |
| `headliner` | `"Sample Band"` |
| `lineup` | `["Sample Band", "Sample Support"]` |
| `performers` | name, page link, genre and image per billed act (when details are fetched) |
| `artistGenres` | `["rock", "alternative"]` |
| `venueName` / `venueUrl` | `"Sample Arena"` / link |
| `venueAddress` / `venueCity` / `venueRegion` / `venueCountry` | `"Sample City, Sample State, Sample Country"` / `"Sample City"` / `"Sample State"` / `"Sample Country"` |
| `locationText` / `locationUrl` | `"Sample City, Sample Country"` / link |
| `description` / `imageUrl` | poster blurb / poster image link (when details are fetched) |
| `ticketUrl` / `ticketVendor` | ticket link / `"Sample Tickets"` |
| `hasSetlist` / `hasPhotos` / `labels` | `true` / `true` / `["Upcoming Concert", "Has Setlist"]` |
| `lineupCount` / `attendeeCount` / `photoCount` | `4` / `42` / `12` |
| `setlists` / `setlistCount` | songs in order per band, plus a link to the setlist page / `1` |
| `changeType` / `changedFields` / `firstSeenAt` / `lastSeenAt` | `"NEW"` (also `"UPDATED"`, `"UNCHANGED"`, `"REAPPEARED"`, `"EXPIRED"`) / `["title"]` / timestamps |

Every record is a concert; there is no separate venue or band record type. Dates come from an archive maintained by fans: very old entries can be approximate, and `startDate` is left empty rather than guessed when the site does not publish a parseable date. Community counters (`attendeeCount`, `photoCount`, `setlistCount`) are counts only; attendee names, comment authors and photo uploader names are never collected.

### How to Use

1. Pick a **mode**: keyword search (band, venue or location) or paste Concert Archives links.
2. In search mode, type a keyword and pick what it should match; in URL mode, paste one link per line.
3. Set the **Upcoming/past** and **Year** filters if you need them, and **Max items** / **Max pages per scope** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search a band's full history:**

```json
{
  "mode": "search",
  "query": "Sample Band",
  "searchType": "bands"
}
```

**Search a venue, upcoming shows only:**

```json
{
  "mode": "search",
  "query": "Sample Arena",
  "searchType": "venues",
  "dateFilter": "upcoming"
}
```

**Paste links (venue history plus one specific concert):**

```json
{
  "mode": "url",
  "urls": [
    "https://www.concertarchives.org/venues/sample-arena",
    "https://www.concertarchives.org/concerts/sample-band--00000000"
  ]
}
```

**URL mode with the field left as it is:** the links box is pre-filled with one example of each supported link type (venue, venue page 2, venue with year and date filter, venue with the upcoming filter, band, location, search, advanced concert search, single concert, and a different band written without `www`). Choosing URL mode without editing it now scrapes those examples instead of nothing. Replace or clear the list to read your own links; Max items is shared across the links.

**Fast, list-only pull with no per-concert surcharge:**

```json
{
  "mode": "search",
  "query": "Sample Band",
  "searchType": "bands",
  "fetchDetails": false,
  "maxItems": 100
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/concert-archives-scraper").call(
    run_input={"mode": "search", "query": "Sample Band", "searchType": "bands"})
for concert in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(concert["startDate"], concert["venueName"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/concert-archives-scraper').call({
  mode: 'search', query: 'Sample Band', searchType: 'bands',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Depth and cost

- **Max items** defaults to 20. Set it to 0 for the whole history, which for a long-running band can be thousands of concerts across dozens of pages.
- In URL mode, **Max items** is shared out evenly across the pasted links (for example 20 across 2 links is up to 10 each). A link that runs out early does not hand its unused share to the others.
- **Max pages per scope** defaults to 0, which means the built-in ceiling of 500 pages per scope (no value walks further), so Max items is the cap that normally stops a run early.
- The **Upcoming/past** and **Year** filters apply to band, venue and location histories (Year to band and venue only). A pasted advanced search link ignores them and the log says so; a pasted single-concert link is always read as-is.
- **Fetch concert details** (on by default) adds a per-concert surcharge for the full billed line-up, description, poster, ticket link and community counts. Turn it off for a fast, list-only pull.
- **Include setlists** (off by default) needs Fetch concert details on, and adds one extra read per concert; it does not add a second surcharge.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues ONE interrupted pull: paste its run or dataset ID and the actor skips every concert already collected there, so you don't pay to collect it twice.
- **Incremental mode** (`incrementalMode`) is for running the same search or link set on a schedule. Each concert is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED`, or `EXPIRED` (only after a run that scanned its whole tracked scope without hitting a cap or a page error, and only with `emitExpired` on). State is kept separately per search, link and filter setup; use `stateKey` to name or deliberately share a monitoring campaign.
- **Counters are kept but never trigger `UPDATED`.** The community counters (`attendeeCount`, `photoCount`, `setlistCount`) are in every row, but by default they are left out of change detection, so a concert that only gained an attendee, photo or setlist stays `UNCHANGED` and is not billed again. A real change to any other field (title, date, venue, line-up and so on) still reports `UPDATED` with it in `changedFields`. Use `ignoreFieldsForChanges` to leave out more fields, for example `ticketUrl`. Changing the list never causes a one-time wave of `UPDATED` rows.
- If you paste more than one link in URL mode, they share one state and one run: `EXPIRED` only fires when every pasted link finished cleanly in that same run, not just the ones that did. A cap hit or a failed page on any one link skips `EXPIRED` for the whole run rather than risk tombstoning a concert that a different link simply did not reach. For example, if you paste a band link and a venue link and the venue page fails to load, no concert from the band link is marked `EXPIRED` in that run either, even though the band link finished.
- **Links that stop early or start late never mark concerts `EXPIRED`.** In URL mode, Max items is split evenly across the pasted links. A link that uses up its share, even partway through its own last page, counts as a cap, so `EXPIRED` is skipped for that run. A link that starts at page 2 or later (for example one ending in `?page=2`) never read the earlier pages, so it also never marks concerts `EXPIRED`; paste the link without `?page=` to allow it.

### Send results into your apps (MCP connectors)

Optionally pipe the results straight into the tools you already use, over Model Context Protocol (MCP). Authorize a connector once under **Apify, Settings, API & Integrations**, then set:

- `mcpConnectors`: the connector IDs to send to, one per line.
- `notionParentPageUrl`: the Notion page to create item pages under, for the Notion connector.
- `maxNotifyListings`: how many items to send per connector per run.

Notion gets one page per concert. Other connectors get a best-effort write or a digest. This never changes the dataset, and a connector problem never fails the scrape. Leave `mcpConnectors` empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (keyword lookup) or `url` (paste links). |
| `query` | string | `the killers` | Search mode: a keyword, for example a band, venue or city name. |
| `searchType` | string | `bands` | Search mode: match the keyword against `bands`, `venues`, or `locations`. |
| `urls` | array | one example of each link type | URL mode: Concert Archives links to read, one per line. |
| `dateFilter` | string | `all` | Narrow the history to `all`, `upcoming`, or `past` concerts. |
| `year` | integer | `0` | Only concerts from this year (`0` = every year). Band and venue pages support it; location pages ignore it and the run says so. |
| `fetchDetails` | boolean | `true` | Read each concert's own page for the full line-up, description, poster, ticket seller and community counts. Adds a per-concert surcharge. |
| `includeSetlists` | boolean | `false` | Also return the songs played, per band. Needs `fetchDetails` on. |
| `maxItems` | integer | `20` | Stop after this many concerts (`0` = no limit). |
| `maxPages` | integer | `0` | Upper bound on pages walked per band, venue, location or link (`0` = built-in ceiling of 500). |
| `resumeFromRunId` | string | (none) | Continue one interrupted pull without collecting the same concerts twice. |
| `incrementalMode` | boolean | `false` | Return only new, changed and reappeared concerts on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode monitoring campaign. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged concerts. |
| `emitExpired` | boolean | `false` | Also return (and bill) concerts no longer found, after a complete scan. |
| `ignoreFieldsForChanges` | array | `[]` | Fields that never make a concert `UPDATED` in incremental mode (kept in the output); the three community counters are already left out by default. Dot paths reach nested fields. |
| `mcpConnectors` | array | (none) | Optional: send results into apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items exported per connector per run. Does not affect the dataset. |
| `proxyConfiguration` | object | Apify Proxy | Connection settings. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "kind": "concert",
  "recordId": "00000000",
  "concertId": "00000000",
  "url": "https://www.concertarchives.org/concerts/sample-band--00000000",
  "slug": "sample-band--00000000",
  "title": "Sample Band",
  "startDate": "2027-01-15",
  "endDate": "2027-01-15",
  "dateText": "Jan 15, 2027",
  "isUpcoming": true,
  "eventStatus": "scheduled",
  "tourName": "Sample World Tour",
  "headliner": "Sample Band",
  "lineup": ["Sample Band", "Sample Support"],
  "performers": [{ "name": "Sample Band", "url": "https://www.concertarchives.org/bands/sample-band", "genre": "rock", "imageUrl": null }],
  "artistGenres": ["rock", "alternative"],
  "venueName": "Sample Arena",
  "venueUrl": "https://www.concertarchives.org/venues/sample-arena",
  "venueAddress": "Sample City, Sample State, Sample Country",
  "venueCity": "Sample City",
  "venueRegion": "Sample State",
  "venueCountry": "Sample Country",
  "locationText": "Sample City, Sample Country",
  "locationUrl": "https://www.concertarchives.org/locations/sample-city",
  "description": "A sample tour stop.",
  "imageUrl": "https://img.example/sample.jpg",
  "ticketUrl": "https://tickets.example/sample",
  "ticketVendor": "Sample Tickets",
  "hasSetlist": true,
  "hasPhotos": true,
  "labels": ["Upcoming Concert", "Has Setlist"],
  "lineupCount": 2,
  "attendeeCount": 42,
  "photoCount": 12,
  "setlists": [{ "artist": "Sample Band", "songs": ["Sample Song One", "Sample Song Two"], "setlistUrl": null }],
  "setlistCount": 1,
  "changeType": "NEW",
  "changedFields": [],
  "firstSeenAt": "2026-09-29T00:00:00+00:00",
  "lastSeenAt": "2026-09-29T00:00:00+00:00"
}
```

### Plan Requirement

The default proxy setting works out of the box on every Apify plan; there is no need to switch to the residential proxy group for this site. When the site's edge answers challenges instead of pages, the actor automatically uses a backup connection for the affected reads and returns to the primary lane afterwards.

### FAQ

#### How much does it cost?

Three events can appear on a run:

- **Actor start:** one event each time a run starts.
- **Per concert row:** one event for each concert row delivered to the dataset.
- **Concert detail surcharge:** one event for each concert whose own page was read, only when Fetch concert details is on. Rows that are skipped as unchanged in incremental mode are not billed this surcharge.

The **Pricing** tab shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Concert Archives?

This actor collects only publicly available concert-history data, and deliberately skips the personal identities behind attendee, comment and photo counts. You are responsible for how you use the results: follow Concert Archives' terms and the laws that apply to you, and get legal advice if you plan commercial redistribution.

#### Can I get only new or changed concerts on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new, updated and reappeared concerts, and unchanged ones are not billed unless you turn on **Emit unchanged**.

#### What is the difference between Resume and Incremental mode?

They solve different problems. **Resume** (`resumeFromRunId`) continues ONE specific interrupted pull so a large history does not need to be collected twice. **Incremental mode** is for running the SAME search or link set again and again (for example weekly) and getting only what changed since last time. Use Resume for a one-off retry, Incremental mode for ongoing monitoring.

#### Why did my run fail instead of returning an empty dataset?

If nothing could be read at all, the run fails with a clear message so "no concerts found" is never confused with "nothing could be read". Run it again in a few minutes. In search mode, a keyword that matches no band, venue or location also stops with a message telling you so: check the spelling or switch Search type. A band, venue or location that genuinely has no concerts for your filters still succeeds with an empty result.

#### Does this collect any personal data from concertgoers?

No. Concerts on Concert Archives carry attendee lists, comments and user-uploaded photos tied to real accounts. This actor returns only the **counts** of those (`attendeeCount`, `photoCount`, `setlistCount`) and never the names, usernames or comment text behind them.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion or another app you authorized under Integrations.

### 🔗 Want more travel data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>✈️ <a href="https://apify.com/abotapi/pollstar-concert-tour-scraper"><b>Pollstar Scraper</b></a><br>Scrape Pollstar upcoming concerts and tour dates: play date, venue with full address and...</td><td>🧩 <a href="https://apify.com/abotapi/bandsintown-concert-event-scraper"><b>Bandsintown Scraper</b></a><br>Scrape Bandsintown concert and festival dates: artist tour calendars, venue profiles...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/songkick-concert-calendar-scraper"><b>Songkick Scraper</b></a><br>Scrape Songkick concert and event calendars: upcoming and past dates, venues, cities...</td><td>🛒 <a href="https://apify.com/abotapi/seatgeek-events-scraper"><b>SeatGeek Scraper</b></a><br>Scrape SeatGeek events with ticket price ranges (lowest, highest, average, median)...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/eventim-de-event-scraper"><b>Eventim Scraper</b></a><br>Scrape CTS Eventim Germany and EU event catalogue: concerts, festivals, comedy, sports...</td><td>🧩 <a href="https://apify.com/abotapi/ticketmaster-event-discovery"><b>Ticketmaster Scraper</b></a><br>Discover and scrape Ticketmaster events across the US, UK, Australia and Canada. Search...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/concert-archives-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Search looks up a band, venue or location by keyword and returns its concert history. URL mode reads the specific Concert Archives pages you paste.

## `query` (type: `string`):

Search mode: a keyword, for example a band name, a venue name or a city. Used together with Search type below.

## `searchType` (type: `string`):

Search mode: what the keyword should match. Bands returns that band's concert and tour history, Venues returns everything played at that venue, Locations returns everything played in that city or region.

## `urls` (type: `array`):

URL mode: pages to read, one per line. Band, venue and location pages are walked forward through their whole history. A single concert link is read as one record. A search link or an advanced concert-search link is also accepted. Multi-value supported.

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

Narrow the concert history to only upcoming or only past concerts. Applies to band, venue and location pages in both modes. Leave on All to return the complete history.

## `year` (type: `integer`):

Return only concerts from this year, for example 2024. Leave at 0 for every year. Band and venue pages support this; location pages do not, and a run that asks for it on a location says so in the log and returns every year instead.

## `fetchDetails` (type: `boolean`):

Read each concert's own page to add the full billed line-up with genres, the description, the poster image, the ticket seller and link, the event status and the community line-up, attendee and photo counts. Adds a per-concert surcharge (see the section caption above).

## `includeSetlists` (type: `boolean`):

Also return the songs played, per band, for concerts that have a setlist on the site. Needs Fetch concert details to be on. This adds one extra read per concert, so runs take longer; it does not add a second surcharge.

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

Stop after this many concerts (0 = no limit; the run then stops when the history runs out).

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

Upper bound on how many pages each band, venue, location or link is walked through (0 = the built-in ceiling of 500 pages per scope, which is also the most any value can walk). Max items is the cap that normally stops a run early.

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

Apify Proxy settings. The prefilled default works on every Apify plan.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning concerts already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching concert as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED concerts. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each search, link and filter setup; use State key to name or deliberately share a monitoring campaign.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search, link and filter settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return concerts that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return concerts that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked history.

## `ignoreFieldsForChanges` (type: `array`):

Field names that should NOT make a concert count as UPDATED when only they change, for example ticketUrl. The community counters (attendeeCount, photoCount, setlistCount) are already left out by default. The fields stay in every row you receive; they are just not compared between runs. Use a dot for nested fields. Changing this list never causes a one-time wave of UPDATED rows.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "query": "the killers",
  "searchType": "bands",
  "urls": [
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?page=2",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?year=2019&date=past",
    "https://www.concertarchives.org/bands/the-killers",
    "https://www.concertarchives.org/locations/singapore-singapore",
    "https://www.concertarchives.org/search?q=the%20killers&search_for=Bands",
    "https://www.concertarchives.org/concert-search-engine?bands_query[]=the+killers&search=true",
    "https://www.concertarchives.org/concerts/disclosure--6347104",
    "https://concertarchives.org/bands/hozier",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?date=upcoming"
  ],
  "dateFilter": "all",
  "year": 0,
  "fetchDetails": true,
  "includeSetlists": false,
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 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 = {
    "mode": "search",
    "query": "the killers",
    "searchType": "bands",
    "urls": [
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?page=2",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?year=2019&date=past",
        "https://www.concertarchives.org/bands/the-killers",
        "https://www.concertarchives.org/locations/singapore-singapore",
        "https://www.concertarchives.org/search?q=the%20killers&search_for=Bands",
        "https://www.concertarchives.org/concert-search-engine?bands_query[]=the+killers&search=true",
        "https://www.concertarchives.org/concerts/disclosure--6347104",
        "https://concertarchives.org/bands/hozier",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?date=upcoming"
    ],
    "dateFilter": "all",
    "year": 0,
    "fetchDetails": true,
    "includeSetlists": false,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "ignoreFieldsForChanges": [],
    "maxNotifyListings": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/concert-archives-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 = {
    "mode": "search",
    "query": "the killers",
    "searchType": "bands",
    "urls": [
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?page=2",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?year=2019&date=past",
        "https://www.concertarchives.org/bands/the-killers",
        "https://www.concertarchives.org/locations/singapore-singapore",
        "https://www.concertarchives.org/search?q=the%20killers&search_for=Bands",
        "https://www.concertarchives.org/concert-search-engine?bands_query[]=the+killers&search=true",
        "https://www.concertarchives.org/concerts/disclosure--6347104",
        "https://concertarchives.org/bands/hozier",
        "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?date=upcoming",
    ],
    "dateFilter": "all",
    "year": 0,
    "fetchDetails": True,
    "includeSetlists": False,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "ignoreFieldsForChanges": [],
    "maxNotifyListings": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/concert-archives-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 '{
  "mode": "search",
  "query": "the killers",
  "searchType": "bands",
  "urls": [
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?page=2",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?year=2019&date=past",
    "https://www.concertarchives.org/bands/the-killers",
    "https://www.concertarchives.org/locations/singapore-singapore",
    "https://www.concertarchives.org/search?q=the%20killers&search_for=Bands",
    "https://www.concertarchives.org/concert-search-engine?bands_query[]=the+killers&search=true",
    "https://www.concertarchives.org/concerts/disclosure--6347104",
    "https://concertarchives.org/bands/hozier",
    "https://www.concertarchives.org/venues/red-rocks-amphitheatre--11?date=upcoming"
  ],
  "dateFilter": "all",
  "year": 0,
  "fetchDetails": true,
  "includeSetlists": false,
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}' |
apify call abotapi/concert-archives-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/concert-archives-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/qnxShYHnGSvvCUcMx/builds/7kpEG71R8nKbb8vab/openapi.json