# Eventim Scraper - DE Events, Dates and Tickets (`abotapi/eventim-de-event-scraper`) Actor

Scrape CTS Eventim Germany and EU event catalogue: concerts, festivals, comedy, sports, dates, venues, prices and availability. Search by city, keyword, category and date, or paste event links. Incremental monitoring with NEW, UPDATED, REAPPEARED, EXPIRED, resume and MCP export.

- **URL**: https://apify.com/abotapi/eventim-de-event-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Eventim Scraper - DE Events, Dates and Tickets

Scrape the CTS Eventim catalogue (Europe's largest ticket shop): concerts,
festivals, comedy, classical, sports and leisure events with dates, venues,
prices and availability across Germany and the EU.

### What it collects

Each event row carries the listing fields plus, with detail fetching on, the
full event page fields:

- Identity: event id, product group id, title, event type and status, URL
- Dates: start and end (ISO 8601 with timezone)
- Venue: name and city on every row; street, region, postal code, country
  and venue URL with detail fetching on
- Tickets: price from, price high, currency, availability, per-tier prices
  with availability each (detail mode), promoter name
- Taxonomy: categories with parent names, tags
- Detail mode only: description, image, offer validity start, and the venue
  address fields beyond name and city
- Incremental mode only: changeType (NEW, UPDATED, REAPPEARED, EXPIRED),
  changedFields, firstSeenAt, lastSeenAt

Sample row (illustrative placeholder values, not a live listing):

```json
{
  "eventId": "00000000",
  "title": "Sample Artist Live at Sample Arena",
  "startDate": "2027-05-01T20:00:00+02:00",
  "venueName": "Sample Arena",
  "venueCity": "Berlin",
  "priceFrom": 49.9,
  "priceCurrency": "EUR",
  "ticketAvailability": "in_stock"
}
```

### Input

Two modes. Search mode queries the catalogue by city, keyword, category,
date window and stock flag. URL mode reads pasted Eventim links: event
links become single records, city and venue links read that scope. The
date window, stock flag and sort order apply in search mode and to pasted
city and venue links; keyword, city and category fields apply to search
mode only.

- `cities`: city names, one per line (Berlin, Hamburg, Munich). Each city is
  one catalogue scope. Empty searches all cities.
- `query`: optional keyword (artist, event or venue name).
- `categories`: for example Concerts, Comedy, Classical, Sports. Each
  category multiplies the city scopes.
- `dateFrom`, `dateTo`: YYYY-MM-DD bounds on the event date.
- `inStockOnly`: only events whose tickets are currently bookable.
- `sort`: DateAsc (default), DateDesc, NameAsc, NameDesc, Rating,
  Recommendation.
- `urls`: event links (read as single records), city and venue links (read
  that city's catalogue scope). Event links are read through the detail
  lane and bill the detail surcharge each, even when Fetch event details
  is off.
- `fetchDetails`: off by default. Reads each event's own page to add the
  description, image, the venue address beyond name and city, price span
  and per-tier prices.
  Detail pages need the slower alternate connection (about 16 seconds per
  event), so enable it only when you need those fields. Adds a per-event
  surcharge.
- `maxItems`: stop after this many events (default 20, 0 means no limit).
- `maxPages`: upper bound on city and category scopes walked (default 0,
  no limit).

Coverage note: the catalogue API serves the first 50 matches per filter
combination and ignores deeper paging, so very large cities return the
soonest 50 per scope. Combine cities with categories and date windows to
cover more of the catalogue. With several scopes and a Max items cap, the
cap is split evenly across the scopes, so each city contributes its share
rather than the run returning the newest events globally.

### Resume and recurring updates

- `resumeFromRunId`: paste a previous run or dataset id to continue a large
  pull without returning events already collected there.
- `incrementalMode`: turn on for scheduled monitoring. The first run marks
  every event NEW. Later runs return only NEW, UPDATED and REAPPEARED
  events unless `emitUnchanged` or `emitExpired` are also on (both return
  and bill extra rows). State is keyed per search setup, or per `stateKey`
  when you name the campaign. EXPIRED rows are only produced after a run
  that finished every scope cleanly.

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

- `mcpConnectors`: connector ids to pipe results into (optional).
- `notionParentPageUrl`: parent page for the Notion export.
- `maxNotifyListings`: cap per connector per run (default 50, dataset
  unaffected).

### Connection

`proxyConfiguration`: Apify Proxy settings. The default (datacenter) works
on every plan and serves the catalogue. Event detail pages refuse ordinary
connections, so detail reads escalate to the result-unblocking lane
automatically (never for runs on custom proxies). Set the environment
variable `EVENTIM_ALTERNATE_CONNECTION=0` to disable that lane.

### Cost

Pay per event pricing: one event record charge per returned row, one actor
start charge per run, plus one detail enrichment charge per event whose
detail page was read (fetchDetails on, or pasted event links). Suppressed
unchanged rows in incremental mode are fetched but never billed.

### Limitations

- Detail reads take about 16 seconds each through the alternate lane; a
  large fetchDetails run can take several minutes.
- Pasted search-page (`/search/`) links are not readable scopes; use a
  city or venue link instead.
- The actor reads the English (`/en/`) catalogue paths.

Independent tool, not affiliated with CTS Eventim. Collects only publicly
available catalogue data. Use responsibly and in line with the site terms.

# Actor input Schema

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

Search reads Eventim by city, keyword, category and date. URL mode reads specific Eventim pages you paste.

## `cities` (type: `array`):

Search mode: city names to cover, one per line, for example Berlin, Hamburg, Munich. Each city is one catalogue scope. Leave empty to search all cities.

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

Search mode: optional keyword, for example an artist, event or venue name. Applied inside every city and category scope.

## `categories` (type: `array`):

Search mode: event categories, one per line, for example Concerts, Comedy, Classical, Sports. Each category multiplies the city scopes. Leave empty for all categories.

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

Only events on or after this date, format YYYY-MM-DD. Applies in search mode and to pasted city and venue links. Leave empty for no lower bound.

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

Only events on or before this date, format YYYY-MM-DD. Applies in search mode and to pasted city and venue links. Leave empty for no upper bound.

## `inStockOnly` (type: `boolean`):

Return only events whose tickets are currently bookable. Applies in search mode and to pasted city and venue links.

## `sort` (type: `string`):

Ordering inside every scope: search mode, and pasted city or venue links.

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

URL mode: Eventim pages to read, one per line. Event links are read as single records; city and venue links read that city's catalogue scope. Multi-value supported.

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

Read each event's own page to add the description, image, full venue address, price span and per-tier prices with availability. Detail pages need the slower alternate connection (about 16 seconds per event), so this is off by default. Adds a per-event surcharge (see the section caption below).

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

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

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

Upper bound on how many city and category scopes are walked (0 = no limit). Each scope serves up to 50 events, so Max items is the cap that normally stops a run first.

## `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 and link 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 and link 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 found, marked EXPIRED. Only produced once a run has fully scanned the tracked search.

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

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API and 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 works on every Apify plan.

## Actor input object example

```json
{
  "mode": "search",
  "cities": [
    "Berlin"
  ],
  "categories": [],
  "inStockOnly": false,
  "sort": "DateAsc",
  "urls": [
    "https://www.eventim.de/en/city/berlin-1/"
  ],
  "fetchDetails": false,
  "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",
    "cities": [
        "Berlin"
    ],
    "categories": [],
    "dateFrom": "",
    "dateTo": "",
    "inStockOnly": false,
    "sort": "DateAsc",
    "urls": [
        "https://www.eventim.de/en/city/berlin-1/"
    ],
    "fetchDetails": false,
    "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/eventim-de-event-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",
    "cities": ["Berlin"],
    "categories": [],
    "dateFrom": "",
    "dateTo": "",
    "inStockOnly": False,
    "sort": "DateAsc",
    "urls": ["https://www.eventim.de/en/city/berlin-1/"],
    "fetchDetails": False,
    "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/eventim-de-event-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",
  "cities": [
    "Berlin"
  ],
  "categories": [],
  "dateFrom": "",
  "dateTo": "",
  "inStockOnly": false,
  "sort": "DateAsc",
  "urls": [
    "https://www.eventim.de/en/city/berlin-1/"
  ],
  "fetchDetails": false,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/eventim-de-event-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/eventim-de-event-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/CZm9yzubYlFe2P4td/builds/pK3akGDRNcRzZNfF0/openapi.json