# Pollstar Scraper - Concert Tours, Venues & Events (`abotapi/pollstar-concert-tour-scraper`) Actor

Scrape Pollstar upcoming concerts and tour dates: play date, venue with full address and coordinates, artist line-up, genres, ticket links and market. Search artists, venues or cities, or paste Pollstar links. Newly-announced filter, incremental monitoring, resume and MCP export.

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

## Pricing

from $1.50 / 1,000 event 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

## Pollstar Scraper: Concert Tours, Venue Calendars & Tour Dates

Pollstar Scraper turns Pollstar into a clean concert-industry data feed. Search an artist, a venue or a city, or paste any Pollstar page, and get structured upcoming event records: play date, venue with street address and coordinates, the full billed line-up with genres, ticket links, market and the venue's own published contact details. Recurring runs can report only what changed, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **One schema across every surface.** The same event record shape covers artist tour schedules, venue calendars and whole-market calendars, so you never write three different parsers.
- **Rich venue data on every row.** Venue name, type, street, city, state, postal code, country, coordinates, market, and the venue's own published phone and website come with each event, with no second request per event.
- **Full line-up, not just the headliner.** Every billed act with its sequence, genres and headline flag, plus a flat support-act list.
- **Newly announced watch.** "Newly announced only" narrows a calendar to the dates Pollstar announced in the last few days, which is the cheapest possible daily tour-announcement feed.
- **Metro widening.** "Include nearby cities" turns a single-city search into a whole surrounding market in one request.
- **Artist profile enrichment, on request.** Optionally add the headline artist's photo, official website, activity status and a touring trivia line; each artist is read once per run and reused across all of their dates.
- **Incremental monitoring and resume, with an honest licence boundary.** Recurring runs can emit only NEW, UPDATED, REAPPEARED or EXPIRED events, an interrupted run can continue without paying twice, and a run that hits Pollstar's data licence wall fails loudly instead of quietly returning nothing.

### Use Cases

- **Booking agents and promoters:** track a market's full calendar to spot open dates and see what else is already booked nearby.
- **Music journalists and tour-news blogs:** watch newly announced dates for a city or artist to publish first.
- **Ticket resale and pricing tools:** feed upcoming event, venue and ticket-link details into a pricing or alerting system.
- **Artist managers and agencies:** monitor a whole roster's tour schedule and venue contact details in one feed.
- **Venue and market analysts:** build a picture of everything booked in a metro area, including nearby cities, without visiting each venue page by hand.

### Data You Get

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

| Field | Example |
| --- | --- |
| `eventId` | `"00000000"` |
| `url` | `https://www.pollstar.com/events/sample-artist-at-sample-arena-00000000` |
| `title` | `Sample Artist at Sample Arena` |
| `playDate` / `playTime` | `2027-06-18T00:00:00` / `8:00 PM` |
| `isFestival` | `false` |
| `announcedHoursAgo` | `36` |
| `headlineArtist` / `headlineArtistUrl` | `Sample Artist` / `https://www.pollstar.com/artists/sample-artist-00000000` |
| `genres` | `["Pop / Rock"]` |
| `supportActs` | `["Sample Support Act"]` |
| `artists` | `[{"artistId": "00000000", "name": "Sample Artist", "isHeadline": true, "genres": ["Pop / Rock"], "artistType": "Band", "sequence": 1}]` |
| `venueName` / `venueTypes` | `Sample Arena` / `["Arena"]` |
| `venueStreet` | `1 Sample Road` |
| `venueCity` / `venueState` | `Sample City` / `ST` |
| `venuePostalCode` / `venueCountry` | `00000` / `United States` |
| `venueLatitude` / `venueLongitude` | `36.1000` / `-115.1000` |
| `venueMarket` | `Sample City, ST` |
| `venuePhone` / `venueEmail` / `venueWebsite` | `(000) 000 0000` / `bookings@sample-arena.example` / `www.sample-arena.example` |
| `ticketUrl` / `ticketVendors` | `https://tickets.example/sample` / `["Sample Ticket Vendor"]` |
| `headlineArtistImageUrl` / `headlineArtistTrivia` | `https://static.example/artist-photos/sample.jpg` / `Sample Artist has headlined 70% of performances since 2006` |
| `scopeKind` / `scopeName` | `city` / `Sample City` |
| `changeType` | `NEW`, `UPDATED`, `REAPPEARED`, `UNCHANGED`, `EXPIRED` |

The `venuePhone`, `venueEmail` and `venueWebsite` fields are the venue's own publicly listed organisation contact details, exactly as Pollstar publishes them on its public venue page. No personal contact data is collected: individual staff and promoter contacts are subscriber-only on Pollstar and this actor does not request them.

### How to Use

1. Pick a **mode**: `search` (look up a name) or `url` (paste Pollstar links).
2. Fill in the fields for that mode, plus the date window and filters that apply to both modes.
3. Set **Max items** (and, if you need it, **Max pages**) to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Everything booked in a market for the next year:**

```json
{
  "mode": "search",
  "query": "Sample City",
  "searchType": "cities",
  "maxItems": 200
}
```

**An artist's upcoming tour dates, with artist profile extras:**

```json
{
  "mode": "search",
  "query": "Sample Artist",
  "searchType": "artists",
  "fetchArtistProfiles": true,
  "maxItems": 100
}
```

**Paste Pollstar links, mixed types supported (links shown are illustrative placeholders):**

```json
{
  "mode": "url",
  "urls": [
    "https://www.pollstar.com/cities/sample-city-00000",
    "https://www.pollstar.com/artists/sample-artist-00000000",
    "https://www.pollstar.com/events/sample-artist-at-sample-arena-00000000"
  ],
  "maxItems": 200
}
```

**Watch a market daily and get only the newly announced dates:**

```json
{
  "mode": "search",
  "query": "Sample City",
  "searchType": "cities",
  "includeNearbyCities": true,
  "newOnly": true,
  "incrementalMode": true,
  "maxItems": 0
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/pollstar-concert-tour-scraper").call(
    run_input={"mode": "search", "query": "Sample City", "searchType": "cities"})
for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["title"], event["playDate"], event["venueName"])
```

JavaScript:

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

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

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

#### The licence boundary this actor respects

Pollstar publishes upcoming tour and venue calendars openly, but licenses its historical archive: the tour history, box-office grosses and venue staff-contact pages are subscriber-only, and the same events feed refuses any date window that reaches into the past. This actor is therefore scoped to upcoming dates only, from today forward, and says so out loud instead of rendering a refusal as an empty calendar:

- A `fromDate` before today is **moved forward to today**, and the run log names both dates.
- A window that ends before today is **refused outright**: the run fails with a message naming the licence boundary, instead of reporting an empty calendar.
- A licence refusal seen partway through a run is **counted and named** in the run's status message, so a partial run is never mistaken for a complete one.

#### How Max items and Max pages shape a run

- **Max items** stops the whole run once that many events have been returned. `0` means no cap, so the run stops only when a calendar reaches its own natural end.
- **Max pages** bounds how many pages ONE artist, venue, city or link is walked through. `0` defaults to a generous 200-page ceiling per scope (roughly 10,000 events), so in practice Max items is normally the only cap you need to touch.
- In `url` mode with several links pasted together, Max items is split evenly across the links. A single very active market or artist can use up its own share while the others finish their calendars naturally; when that happens before the link's last page, it is enough to mark the whole run as capped for the incremental-mode rules below, even though most links completed a full scan. See the next section for the one case where it is not marked.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run or dataset ID and the actor skips every event id already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for repeated runs over the same search, links and filters. Each event is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only after a run that fully scanned the tracked scope, and only with `emitExpired` on). `stateKey` names or shares the stored state. With incremental mode off, output is exactly as before.
- EXPIRED rows are only produced when the run believes nothing capped, resumed or refused the scan partway. In `url` mode with several links, one link using up its own Max items share before its calendar's last page is enough to skip EXPIRED detection for that whole run, even when every other link finished naturally; the run simply tries again next cycle.
- One edge case goes the other way. In `url` mode with several links and a non-zero Max items, if a link's share runs out partway through the LAST page of that link's calendar while the run as a whole stays under Max items, the run does not count that as a cap. The events on that page after the cutoff were never read, so they can be reported (and billed) as EXPIRED even though they are still listed, and they come back as REAPPEARED on a later run that reads them. If you turn on `emitExpired` in `url` mode with more than one link, set Max items to `0` (no cap), or run each link on its own, so every EXPIRED row reflects a date that is really gone.

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

You can optionally pipe results into apps you already use via Model Context Protocol (MCP) connectors. Authorize a connector under Apify, Settings, API & Integrations, then select it in the `mcpConnectors` input field. For Notion, set `notionParentPageUrl` to the page under which item pages are created; the Notion export writes a page per event with a readable summary. Other connectors get a best-effort write or digest.

Each connector receives a condensed, human-readable summary per event (title plus the key fields flattened to plain text), not the full record. The complete event record always stays in the Apify dataset. `maxNotifyListings` caps how many items each connector receives per run and never changes the dataset. Leave `mcpConnectors` empty to skip the export entirely.

Requires an Apify account. The default settings work on every plan.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` resolves a keyword to a Pollstar artist, venue or city. `url` reads the Pollstar pages you paste. |
| `query` | string | `Las Vegas` | Search mode: the name to look up. The closest Pollstar match is used and logged. |
| `searchType` | string | `cities` | Search mode: `cities`, `artists` or `venues`. Cities returns everything booked in a market, artists returns a tour schedule, venues returns a venue calendar. |
| `urls` | array of strings | empty | URL mode: Pollstar pages, one per line. Artist, venue, city and company pages are paged forward; a single event page is read as one record. Every link must end in the numeric Pollstar id. |
| `fromDate` | string | today | First play date to include, `YYYY-MM-DD`. A date before today is moved forward to today and the run log says so. |
| `toDate` | string | one year out | Last play date to include, `YYYY-MM-DD`. |
| `newOnly` | boolean | `false` | Only dates Pollstar announced in the last few days. |
| `includeNearbyCities` | boolean | `false` | Widen a city search into the surrounding metro area. Ignored for artist, venue and event scopes. |
| `sortOrder` | string | `asc` | `asc` reads the calendar soonest first, `desc` furthest out first. Pollstar only orders this feed by play date, so that is the only ordering offered. |
| `fetchArtistProfiles` | boolean | `true` | Read each headline artist's Pollstar profile for their photo, website, activity status and trivia line. Adds a per-event surcharge; each artist is read once per run. |
| `maxItems` | integer | `20` | Stop after this many events. `0` means no limit. |
| `maxPages` | integer | `0` | Upper bound on pages read per artist, venue, city or link. `0` defaults to a wide 200-page ceiling so `maxItems` is normally the only cap you need. |
| `resumeFromRunId` | string | empty | A previous run or dataset ID to continue without returning events already collected there. |
| `incrementalMode` | boolean | `false` | Recurring monitoring: the first run marks every event NEW; later runs emit only NEW, UPDATED and REAPPEARED events, plus EXPIRED when enabled. |
| `stateKey` | string | empty | Optional name for a monitoring campaign so its state stays stable, or to deliberately share state across runs. |
| `emitUnchanged` | boolean | `false` | Also return events that have not changed since the last run, marked UNCHANGED. Returns and bills extra rows. |
| `emitExpired` | boolean | `false` | Also return events tracked before but no longer listed, marked EXPIRED. Only produced after a run fully scans the tracked calendar. |
| `mcpConnectors` | array of strings | empty | Optional MCP connectors to receive the results (see the section above). |
| `notionParentPageUrl` | string | empty | Parent Notion page for the Notion connector export. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |
| `proxyConfiguration` | object | standard | Apify Proxy settings. The default is the standard automatic Apify proxy and works on every plan. No proxy group is pinned. |

### Output Example

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

```json
{
  "kind": "event",
  "recordId": "00000000",
  "eventId": "00000000",
  "url": "https://www.pollstar.com/events/sample-artist-at-sample-arena-00000000",
  "title": "Sample Artist at Sample Arena",
  "playDate": "2027-06-18T00:00:00",
  "playTime": "8:00 PM",
  "isFestival": false,
  "hasBoxOfficeReport": false,
  "announcedHoursAgo": 36,
  "note": null,
  "headlineArtist": "Sample Artist",
  "headlineArtistId": "00000000",
  "headlineArtistUrl": "https://www.pollstar.com/artists/sample-artist-00000000",
  "headlineArtistType": "Band",
  "genres": ["Pop / Rock"],
  "supportActs": ["Sample Support Act"],
  "artists": [
    {
      "artistId": "00000000",
      "name": "Sample Artist",
      "url": "https://www.pollstar.com/artists/sample-artist-00000000",
      "isHeadline": true,
      "genres": ["Pop / Rock"],
      "artistType": "Band",
      "sequence": 1
    }
  ],
  "venueId": "00000000",
  "venueName": "Sample Arena",
  "venueUrl": "https://www.pollstar.com/companies/sample-arena-00000000",
  "venueTypes": ["Arena"],
  "venueMarket": "Sample City, ST",
  "venueStreet": "1 Sample Road",
  "venueCity": "Sample City",
  "venueState": "ST",
  "venueStateName": "Sample State",
  "venuePostalCode": "00000",
  "venueCountry": "United States",
  "venueLatitude": 36.1,
  "venueLongitude": -115.1,
  "venuePhone": "(000) 000 0000",
  "venueEmail": "bookings@sample-arena.example",
  "venueWebsite": "www.sample-arena.example",
  "tickets": [
    {
      "vendor": "Sample Ticket Vendor",
      "url": "https://tickets.example/sample",
      "doorTime": "8:00 PM"
    }
  ],
  "ticketUrl": "https://tickets.example/sample",
  "ticketVendors": ["Sample Ticket Vendor"],
  "headlineArtistImageUrl": "https://static.example/artist-photos/sample.jpg",
  "headlineArtistWebsite": "www.sample-artist.example",
  "headlineArtistIsActive": true,
  "headlineArtistSortName": "SAMPLE ARTIST",
  "headlineArtistNote": null,
  "headlineArtistTrivia": "Sample Artist has headlined 70% of performances since 2006",
  "scopeKind": "city",
  "scopeId": "00000",
  "scopeName": "Sample City"
}
```

### Plan Requirement

The default proxy setting works out of the box on every Apify plan, and this actor does not pin any paid proxy group. Optional artist profile enrichment (`fetchArtistProfiles`) adds a small per-event surcharge on top of the base per-record charge; the **Pricing** tab shows current rates for both.

### FAQ

#### How much does it cost?

You pay per event returned, plus the artist-profile surcharge only for the events whose headline artist was actually read fresh during that run (a cached or reused artist never re-bills). The **Pricing** tab shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Pollstar?

This actor collects only the upcoming-events data Pollstar's own public web app already serves without a login. You are responsible for how you use it: follow Pollstar's terms and the laws that apply to you, and get legal advice before any commercial redistribution, especially given that Pollstar licenses its historical archive (tour history and box-office data) separately and this actor does not access it.

#### Can I watch a market or artist for newly announced dates on a schedule?

Yes. Schedule the actor from the **Schedules** tab, turn on **Newly announced only** and **Incremental changes for scheduled runs**. Each run then returns only NEW, UPDATED and REAPPEARED dates; unchanged ones are skipped and not billed unless you also turn on **Emit unchanged**.

#### Why did my date window get moved forward, or my run fail instead of returning an empty dataset?

Pollstar licenses dates before today; this actor moves a past start date forward to today and logs the change. A window that ends entirely in the past is refused, and the run fails with a message naming the licence boundary rather than reporting an empty calendar, so "nothing booked" is never confused with "the request itself was refused". If only part of a run was refused, you still get what could be read, and the run's status message names how much was blocked.

#### Why didn't an incremental run report any EXPIRED dates I expected?

EXPIRED detection only fires after a run that fully scanned its tracked scope with nothing capped, resumed or refused. In `url` mode with several links, Max items is split per link, so one especially active link using up its own share before its last page is enough to skip EXPIRED for the whole run that cycle, even though the other links finished naturally; that cycle's tombstoning is simply deferred. The opposite edge case also exists: if a link's share runs out partway through its final page while the run stays under Max items overall, the unread rest of that page can be reported as EXPIRED and then return as REAPPEARED later (see "Resume and recurring updates" above). For reliable EXPIRED rows in `url` mode with several links, set Max items to `0` or run each link on its own.

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

**Resume** continues ONE specific interrupted run so you don't pay to re-collect what it already gathered. **Incremental mode** is for running the same search or links again and again (for example daily) and getting only what is new or changed since last time. They are independent and can be combined.

#### 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, Linear or Airtable.

### 🔗 Want more travel data?

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

<table>
<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/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/concert-archives-scraper"><b>Concert Archives Scraper</b></a><br>Scrape Concert Archives concert and tour history: past and upcoming dates, venues...</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>
<tr><td>🧩 <a href="https://apify.com/abotapi/viagogo-events-scraper"><b>Viagogo Scraper</b></a><br>Scrape Viagogo events by artist, production, venue, city, category, or URL. Extract event...</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>
</table>

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

### 💬 Support & custom scrapers

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

# Actor input Schema

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

Search resolves a keyword to a Pollstar artist, venue or city and returns its upcoming events. URL mode reads the specific Pollstar pages you paste.

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

Search mode: the name to look up, for example an artist, a venue or a city. The closest Pollstar match is used and its name is logged.

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

Search mode: what the keyword should resolve to. Artists returns a tour schedule, Venues returns a venue calendar, Cities returns everything booked in a market.

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

URL mode: Pollstar pages to read, one per line. Artist, venue, city and company pages are paged forward; a single event page is read as one record. Every link must end in the numeric Pollstar id. Multi-value supported.

## `fromDate` (type: `string`):

First play date to include. Leave empty for today. Pollstar licenses historical data, so a date before today is moved forward to today and the run says so in its log.

## `toDate` (type: `string`):

Last play date to include. Leave empty for one year after the start date.

## `newOnly` (type: `boolean`):

Return only dates Pollstar announced in the last few days. Ideal for a daily tour-announcement watch.

## `includeNearbyCities` (type: `boolean`):

Widen a city search to the surrounding metro area, adding events at venues in neighbouring cities. Ignored for artist, venue and event scopes.

## `sortOrder` (type: `string`):

Read the calendar from the nearest date forward, or from the furthest date backward. Pollstar only orders this feed by play date, so that is the only ordering offered.

## `fetchArtistProfiles` (type: `boolean`):

Read each headline artist's Pollstar profile to add their photo, official website, activity status and a touring trivia line. Adds a per-event surcharge (see the section caption below); each artist is read once per run and reused across their other dates.

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

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

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

Upper bound on how many pages each artist, venue, city or link is walked through. Defaults wide open so Max items is the only cap that stops a run early.

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

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

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

Turn this on for daily or recurring monitoring. The first run returns every matching event as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED events. 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 events 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 events that were present in a previous run but are no longer listed, marked EXPIRED. Only produced once a run has fully scanned the tracked calendar.

## `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.

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

Apify Proxy settings. The prefilled default is the standard automatic Apify proxy, which works on every Apify plan. No proxy group is pinned, so the default never depends on a paid plan feature.

## Actor input object example

```json
{
  "mode": "search",
  "query": "Las Vegas",
  "searchType": "cities",
  "urls": [
    "https://www.pollstar.com/cities/las-vegas-32868"
  ],
  "newOnly": false,
  "includeNearbyCities": false,
  "sortOrder": "asc",
  "fetchArtistProfiles": true,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": "Las Vegas",
    "searchType": "cities",
    "urls": [
        "https://www.pollstar.com/cities/las-vegas-32868"
    ],
    "newOnly": false,
    "includeNearbyCities": false,
    "sortOrder": "asc",
    "fetchArtistProfiles": true,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/pollstar-concert-tour-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": "Las Vegas",
    "searchType": "cities",
    "urls": ["https://www.pollstar.com/cities/las-vegas-32868"],
    "newOnly": False,
    "includeNearbyCities": False,
    "sortOrder": "asc",
    "fetchArtistProfiles": True,
    "maxItems": 20,
    "maxPages": 0,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/pollstar-concert-tour-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": "Las Vegas",
  "searchType": "cities",
  "urls": [
    "https://www.pollstar.com/cities/las-vegas-32868"
  ],
  "newOnly": false,
  "includeNearbyCities": false,
  "sortOrder": "asc",
  "fetchArtistProfiles": true,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/pollstar-concert-tour-scraper --silent --output-dataset

```

## MCP server setup

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