# Songkick Scraper \[💰$2/1K] | Concerts | Tour Dates (`ahmed_jasarevic/songkick-scraper`) Actor

Scrape concert and tour-date intelligence from songkick.com: artist gigographies, upcoming calendars, venue and metro-area event listings, performers and genres, ticket vendors with prices and availability, and artist follower counts.

- **URL**: https://apify.com/ahmed_jasarevic/songkick-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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

## Songkick Scraper — Concerts, Tour Dates & Ticket Availability

Scrape **concert and tour-date intelligence** from [songkick.com](https://www.songkick.com): artist gigographies (past shows) and upcoming calendars, venue and metro-area event listings, schema.org `MusicEvent` JSON-LD, performers and genres, ticket vendors with prices and availability, and artist follower counts. One dataset carrying three record types — `event`, `artist` and `venue`.

Built for concert-discovery apps, tour managers and music-marketing teams, ticketing and secondary-market analysts, and event-calendar integrations. The default dataset is one row per event, enriched from the artist's own page or a metro-area listing.

### Scrape Concert & Tour Date Data For Event Calendars And Ticket Analysis

- **Tour-date and concert calendars** — start and end date/time, status, attendance mode, venue and metro area
- **Ticket availability tracking** — vendor, price and `On sale now` / `Sold out` status per event
- **Artist market research** — follower ("fans") counts, genre lists and full past gigographies
- **Venue and metro-area coverage** — full street address, city, region, postal code, country and latitude/longitude on every event
- **Building a structured music-event database** — the raw schema.org `MusicEvent` JSON-LD is returned verbatim alongside the mapped fields
- **Historical tour analysis** — paginated past gigographies per artist, page by page

### How It Works

![How the Songkick Scraper works: artist and city pages become concert, artist and venue rows from schema.org MusicEvent data.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-songkick-scraper)

Songkick is server-rendered but rejects non-browser TLS fingerprints. The Actor uses Crawlee's browser-like HTTP client, reads the schema.org MusicEvent JSON-LD on artist, metro-area and concert pages, and resolves names through Songkick's universal search API.

Each row is an event, artist or venue with dates, full venue address and coordinates, performers, genres, ticket offers and availability, plus source URLs.

Songkick is a server-rendered Rails app behind **Fastly**. A plain `curl` to any non-cached page returns HTTP 406 with an empty body — the edge rejects requests whose TLS fingerprint does not look like a real browser. The Actor uses `CheerioCrawler` with Crawlee's browser-like HTTP client, which passes that check — every page returns 200 with no browser, no cookies and no challenge solving.

Two structured data surfaces are read, in order of preference:

1. **Embedded schema.org JSON-LD (primary).** Every artist, gigography, metro-area and concert page ships `<script type="application/ld+json">` blocks, each containing a JSON array with one `MusicEvent` object. These are parsed directly with Cheerio — no DOM scraping of event cards. This is where venue address, geo coordinates, performers, genres and dates come from.
2. **Internal JSON API (discovery).** `https://www.songkick.com/api/universal_search?query=<q>` is the site's own search endpoint, returning clean JSON with `artists`, `venues`, `events`, `past_events` and `top_results` — used to resolve artist names to IDs and to power free-text search mode.

Ticket details come from the concert page's "Buy tickets" block (vendor, sale status, price and the `/tickets/{id}` redirect URL).

| Purpose | URL |
| --- | --- |
| Artist name → id | `https://www.songkick.com/api/universal_search?query={name}` |
| Upcoming calendar | `https://www.songkick.com/artists/{id}` |
| Past gigography | `https://www.songkick.com/artists/{id}/gigography?page={n}` |
| Metro-area listings | `https://www.songkick.com/metro-areas/{id}?page={n}` |
| Ticket details | `https://www.songkick.com/concerts/{eventId}` |

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `artistNames` | array | No | — | Artist names, resolved to Songkick artists via the search API. |
| `artistUrls` | array | No | — | Direct artist URLs or bare numeric artist IDs. |
| `metroAreaUrls` | array | No | — | Metro-area URLs or bare numeric metro-area IDs. |
| `searchQueries` | array | No | — | Free-text queries against Songkick's search index. |
| `includeUpcomingEvents` | boolean | No | `true` | Scrape the artist's upcoming calendar. |
| `includePastEvents` | boolean | No | `false` | Scrape the past gigography, paginated. Charged per page fetched. |
| `includeTicketDetails` | boolean | No | `false` | Fetch each concert page for ticket vendors, prices and availability. Charged per concert page fetched. |
| `maxItems` | integer | No | `1000` | Max records pushed across all sources; the crawl stops when reached. |
| `maxRequestsPerCrawl` | integer | No | `1000` | Hard request cap. |
| `proxy` | object | No | off | Standard Apify proxy configuration; off by default. |

Free-plan runs return a 10-record preview; paying runs run to the configured limits.

### Output Fields

Three record types are pushed to the dataset: `event`, `artist` and `venue`.

| Field | Description |
| --- | --- |
| `recordType` | `event`, `artist` or `venue`. |
| `eventId` / `eventName` / `eventUrl` | Songkick concert ID, title and canonical URL. |
| `startDate` / `endDate` | Event start and end date/time (ISO 8601). |
| `eventStatus` / `attendanceMode` | schema.org status (`EventScheduled`, …) and attendance mode. |
| `venue` | Venue name, full street address, city, region, postal code, country, latitude/longitude, website. |
| `performers` | Lineup with each performer's name, genres and Songkick artist URL. |
| `genres` | De-duplicated genre list across the lineup. |
| `offers` | schema.org offers (ticket URLs). |
| `ticket` | Ticket vendors, prices and availability (`On sale now` / `Sold out`) — when ticket details are on. |
| `artist` | Artist ID, name, URL and follower ("fans") count. |
| `metroArea` | Metro-area ID, name and URL for city listings. |
| `schemaOrg` | The raw schema.org `MusicEvent` JSON-LD object, verbatim. |
| `sourceType` / `sourceUrl` | Where the record came from: `artist`, `artist-gigography`, `metro-area` or `search`. |

### Example Input

Concerts for two artists, plus a metro-area calendar, with past shows and ticket details:

```json
{
  "artistNames": ["Radiohead", "Mary In The Junkyard"],
  "metroAreaUrls": ["16021-us-wichita"],
  "searchQueries": ["indie rock"],
  "includePastEvents": true,
  "includeTicketDetails": true,
  "maxItems": 1000
}
```

### Example Output

```json
{
  "recordType": "event",
  "eventId": "43222413",
  "eventName": "Mary In The Junkyard @ Sid The Cat Auditorium",
  "eventUrl": "https://www.songkick.com/concerts/43222413-mary-in-the-junkyard-at-sid-the-cat-auditorium",
  "startDate": "2026-11-02T20:00:00",
  "endDate": "2026-11-02",
  "eventStatus": "https://schema.org/EventScheduled",
  "venue": {
    "name": "Sid The Cat Auditorium",
    "streetAddress": "1022 El Centro Street",
    "addressLocality": "South Pasadena",
    "addressRegion": "CA",
    "postalCode": "91030",
    "addressCountry": "US",
    "latitude": 34.11502,
    "longitude": -118.15561,
    "website": "https://www.sidthecat.com/"
  },
  "performers": [
    { "name": "Mary In The Junkyard", "genres": [], "url": "https://www.songkick.com/artists/10188892-mary-in-the-junkyard" },
    { "name": "Lefty Parker", "genres": [], "url": "https://www.songkick.com/artists/10265622-lefty-parker" }
  ],
  "genres": ["indie"],
  "offers": [],
  "ticket": {
    "statusMessage": "sold_out",
    "vendors": [
      { "vendor": "DICE", "status": "Sold out", "price": "US $28.31", "url": "https://www.songkick.com/tickets/34049258?" }
    ],
    "isSoldOut": true,
    "onSale": false
  },
  "artist": { "artistId": "10188892", "artistName": "Mary In The Junkyard", "followers": 7225 },
  "metroArea": null,
  "schemaOrg": { "@type": "MusicEvent", "...": "..." },
  "sourceType": "artist",
  "sourceUrl": "https://www.songkick.com/artists/10188892-mary-in-the-junkyard"
}
```

### Automate Tour-Date Monitoring With Schedules & Webhooks

- **Schedule the Actor** weekly to re-crawl a list of artists and diff newly announced shows, sold-out flips and added tour dates.
- **Webhooks** — configure a run-success webhook so each finished run POSTs to n8n, Make or Zapier and lands in a CRM, spreadsheet or calendar feed.
- **Apify API** — pull the dataset programmatically with the JavaScript or Python client, or export JSON / CSV / Excel from the console.
- Recurring runs are what keep a tour calendar current; new dates and ticket-status changes land constantly.

### Related Actors

- [Songkick Scraper — Concert & Event Calendar](https://apify.com/abotapi/songkick-concert-calendar-scraper) — Songkick concert calendars with incremental monitoring across many countries.
- [Songkick Concert & Event Scraper](https://apify.com/lulzasaur/songkick-scraper) — Songkick concerts and events.
- [Eventbrite Pro Scraper](https://apify.com/ahmed_jasarevic/eventbrite-pro-event-scraper) — events, leads, ticket data and event pages from Eventbrite globally.
- [Ticketmaster Scraper](https://apify.com/ahmed_jasarevic/ticketmaster-scraper) — events and ticket status from Ticketmaster.
- [SeatGeek Scraper](https://apify.com/ahmed_jasarevic/seatgeek-scraper) — concert and sports price data from SeatGeek.

### Frequently Asked Questions

#### Why use this Actor instead of the official Songkick API?

Songkick does operate a public API (`api.songkick.com`), but access is gated behind a signed partnership agreement and a licence fee, and Songkick has stated it is currently unable to process new API-key applications. It also does not approve student, educational or hobbyist projects, and its terms restrict how long retrieved data may be kept. This Actor instead reads the same publicly visible artist, gigography, metro-area and concert pages plus Songkick's own public search endpoint, so you can pull tour dates, ticket availability and artist data with no key, no contract and no approval queue.

#### What are alternatives to Songkick for concert and tour-date data?

Three routes exist. First, Ticketmaster and SeatGeek — both publish open developer APIs (Ticketmaster Discovery, SeatGeek) and cover primary and secondary ticket inventory, so they are the usual companions rather than replacements. Second, event platforms like Eventbrite, which publish listings for independent and free shows that major aggregators miss. Third, self-serve scraping of the aggregators (this Actor and the ones in Related Actors). Songkick is generally the deepest source for artist gigographies and metro-area calendars.

#### Can an AI agent call this Actor?

Yes. It is a standard Apify Actor, so any MCP client or agent can start a run through the Apify API or the Apify MCP server, wait for it to finish, and read the dataset items. The minimal input and output field list are in the next section.

#### Does this Actor return ticket prices and sold-out status?

Yes, but only when `includeTicketDetails` is `true` (off by default). Each concert page's "Buy tickets" block is then fetched and parsed for vendor, sale status, price and the redirect URL. The `ticket` object carries the vendors array plus `isSoldOut` and `onSale` flags. Upcoming events themselves always ship inside the artist page's JSON-LD, which is fetched regardless — so the base event, venue and lineup data costs nothing extra.

#### How deep is the historical tour data?

Artist pages show a limited number of upcoming events (typically 10–15). The full history lives in the paginated gigography, reached with `includePastEvents: true`; pagination keeps following "next page" while pages still return events, until `maxItems` records have been pushed or the sources run dry. Each past-gigography page is charged separately.

#### How much does it cost?

Pay-per-event: every record written to the dataset is charged ($2 per 1,000 records). The two optional features that spend extra HTTP requests — `ticket-details` and `gigography-page` — carry their own per-request charges, shown on the Actor's pricing page. Upcoming events cost nothing beyond the base record.

### For AI Agents & LLM Apps

Purpose: return structured concert and tour-date data (events with venue, geo, lineup, ticket status, artist followers) from songkick.com as JSON rows, in three record types: `event`, `artist`, `venue`.

Minimal input (upcoming concerts for one artist):

```json
{ "artistNames": ["Radiohead"] }
```

Variant — artists, a metro area and free-text search, with past shows and ticket details:

```json
{
  "artistNames": ["Radiohead", "Mary In The Junkyard"],
  "metroAreaUrls": ["16021-us-wichita"],
  "searchQueries": ["indie rock"],
  "includePastEvents": true,
  "includeTicketDetails": true,
  "maxItems": 1000
}
```

Output fields (default dataset): `recordType`, `eventId`, `eventName`, `eventUrl`, `startDate`, `endDate`, `eventStatus`, `attendanceMode`, `venue`, `performers`, `genres`, `offers`, `ticket`, `artist`, `metroArea`, `schemaOrg`, `sourceType`, `sourceUrl`.

Behaviors an agent should know:

- There are four independent source inputs — `artistNames`, `artistUrls`, `metroAreaUrls`, `searchQueries` — and any combination can be used in one run; records are tagged with `sourceType` so you can tell them apart afterward.
- `artistNames` are resolved to Songkick artist IDs through the public search endpoint; `artistUrls` and `metroAreaUrls` also accept bare numeric IDs, which skips the resolution request.
- `includeUpcomingEvents` defaults to `true` and is free of extra HTTP requests — upcoming events ship inside the artist page's JSON-LD, which is fetched anyway.
- `includePastEvents` and `includeTicketDetails` both default to `false` and each add per-request charges; enable them only when you need gigography history or ticket vendors/prices/availability.
- Each concert page is fetched (and charged) at most once per run, even when the same event appears in multiple sources.
- `genre` lists on artist-page JSON-LD are often empty; metro-area pages usually carry genres. The Actor returns whatever the site provides.
- The proxy input is off by default — direct connection works because of the browser-like TLS impersonation described above.

Billing: pay-per-event — one record per event/artist/venue row ($2 / 1,000). Optional `ticket-details` and `gigography-page` charges are listed on the pricing page; budget those separately from the record count.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Songkick. It reads only publicly visible artist, gigography, metro-area and concert pages plus Songkick's own public search endpoint — no login, no account and no access to private or member-only data. Artist follower counts, venue addresses and ticket links are already displayed publicly on the pages the Actor reads. You are responsible for your own compliance with Songkick's Terms of Service and with applicable data-protection law (including the GDPR where personal data is present) when scaling or redistributing the data.

### SEO Keywords

songkick scraper, concert calendar data, tour dates api, songkick api alternative, live music data, concert listings scraper, tour date database, artist gigography data, concert ticket availability, venue event data, music event scraper, live events database, concert market research, songkick data export, concert date tracking, ticket status scraper, music marketing data, metro area events, concert discovery data, event calendar api, songkick concert scraper, live music calendar, tour tracking tool

# Actor input Schema

## `artistNames` (type: `array`):

Artist names to look up (e.g. "Radiohead", "Mary In The Junkyard"). Each name is resolved to a Songkick artist via the site's own search API, then the artist's upcoming calendar (and optionally past gigography) is scraped.

## `artistUrls` (type: `array`):

Direct Songkick artist URLs (e.g. https://www.songkick.com/artists/253846-radiohead) or bare numeric artist IDs (e.g. 253846). Skips the name-resolution step.

## `metroAreaUrls` (type: `array`):

Songkick metro-area URLs (e.g. https://www.songkick.com/metro-areas/16021-us-wichita) or bare numeric metro-area IDs (e.g. 16021). Returns upcoming events in that city, paginated.

## `searchQueries` (type: `array`):

Free-text queries run against Songkick's search index. Returns matching artists, venues and events (upcoming + past) as separate records.

## `includeUpcomingEvents` (type: `boolean`):

Scrape the artist's upcoming calendar (from the artist page).

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

Also scrape the artist's past gigography, paginated. Adds one request per page per artist.

## `includeTicketDetails` (type: `boolean`):

Fetch each event's concert page to add ticket vendors, prices and availability (on sale / sold out). Adds one extra request per event.

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

Maximum number of records to push to the dataset across all sources. The crawler keeps going (pagination included) until it has pushed this many records or run out of events to scrape.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on the total number of HTTP requests the crawler may make.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "artistNames": [
    "Radiohead"
  ],
  "includeUpcomingEvents": true,
  "includePastEvents": false,
  "includeTicketDetails": false,
  "maxItems": 1000,
  "maxRequestsPerCrawl": 1000,
  "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 = {
    "artistNames": [
        "Radiohead"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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