# Eventim Scraper — Events, Dates & Ticket Prices for Germany (`techforce.global/eventim-scraper`) Actor

Extract concerts, shows, and live events from Eventim.de — titles, dates, venues, ticket prices, and availability in bulk. Covers all major German cities. No manual copy-paste. Export ready to CSV, JSON, or Excel in minutes. Built for event agencies, promoters, venue managers, and marketing teams.

- **URL**: https://apify.com/techforce.global/eventim-scraper.md
- **Developed by:** [Techforce Global](https://apify.com/techforce.global) (community)
- **Categories:** Automation, Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Eventim.de Event Scraper — High-Performance Event & Ticket Intelligence

The Eventim Germany Event Scraper is a professional-grade intelligence tool designed to extract real-time data from the Eventim.de public API. Unlike DOM-based scrapers that are slow and fragile, this Eventim.de scraper Actor communicates directly with the API to deliver massive datasets in seconds with **99.9% reliability**.

Whether you are building a ticket resale platform, a local discovery app, or conducting market research on the German entertainment sector, this is the most stable and cost-effective solution on the Apify Store.

---

### ⚡ Why This Actor Is Different

| Feature          | This Actor (API-Driven)               | Traditional Scrapers (DOM)           |
| ---------------- | ------------------------------------- | ------------------------------------ |
| **Speed**        | 100+ events in under 30 seconds       | 5–10 minutes                         |
| **Reliability**  | Won't break when the UI changes       | Breaks frequently                    |
| **Cost**         | Extremely low credit consumption      | High — requires heavy browsers       |
| **Data Quality** | Clean, structured JSON from source    | Often contains HTML artifacts        |
| **Bot Bypass**   | Bypasses 100% of visual bot detection | Often blocked by PerimeterX / Akamai |

---

### ⭐ Key Features

- **Direct API Access** — No login, user account, or cookies required.
- **Granular City Filtering** — Target specific German hubs (Berlin, München, Hamburg, etc.) or scrape all of Germany at once.
- **Ticket Availability Tracking** — Use the `inStock` filter to surface only buyable, live events.
- **English & German Support** — Extract data in either language for international platforms.
- **Rich Metadata** — Includes venue details, stock status, event categories, and direct URLs.
- **Automation Ready** — Native JSON output designed for seamless n8n or Zapier workflows.

---

### 🧩 Input Configuration

| Field        | Type    | Description                                                   |
| ------------ | ------- | ------------------------------------------------------------- |
| `searchTerm` | String  | Artist name, tour title, or specific venue                    |
| `cityNames`  | Array   | e.g. `["Berlin", "Hamburg"]` — leave empty for all of Germany |
| `categories` | Array   | Konzerte, Sport, Theater, Musical, Festival, etc.             |
| `inStock`    | Boolean | When `true`, filters out sold-out events                      |
| `maxResults` | Number  | Total items to fetch — max 1,000 per run for stability        |

---

### 📊 Example Output

```json
{
  "name": "Coldplay - Music Of The Spheres World Tour",
  "status": "Available",
  "inStock": true,
  "startDate": "2026-07-15T20:00:00+02:00",
  "venue": "Olympiastadion Berlin",
  "city": "Berlin",
  "categories": "Konzerte, Rock/Pop",
  "url": "https://www.eventim.de/event/coldplay-olympiastadion-berlin-123456/"
}
````

***

### 🧠 Strategic Use Cases

**📈 Market Intelligence**
Monitor pricing trends and event volume across different German states over time.

**🤝 Lead Generation**
Identify upcoming large-scale events for local security, catering, or transport businesses.

**📅 Event Aggregation**
Power your own "What's On" website or newsletter with the most accurate data in Germany.

**🎟️ Ticket Resale Analysis**
Track when sold-out events suddenly have new stock released.

***

### 💡 Growth Hack: Automated Telegram Alerts via n8n

Connect this Actor to n8n to build a "Low Stock Alert" bot:

1. Set the Actor to run on an hourly schedule.
2. Filter for `inStock: true`.
3. Send a Telegram notification whenever a high-demand concert (e.g. Taylor Swift, Coldplay) shows new availability.

This Actor integrates seamlessly with **n8n** for fully automated, end-to-end workflows — no manual steps required.

***

### 🆘 Support

For issues, custom role requests, or feature suggestions:

**Email**: bhavin.shah@techforceglobal.com

***

### 🔗 You Might Also Like

[All Events Scraper](https://apify.com/techforce.global/all-events-scraper)

[Events Eye Scraper Global trade show data](https://apify.com/techforce.global/events-eye-scraper)

***

#### Need a Custom Pipeline?

#### [📅 Book a Free 15-min Consultation](https://calendly.com/techforce-infotech-pvt-ltd/intro-meeting?month=2026-01)

***

Made with ❤️ by **[Techforce](https://www.techforceglobal.com)**
Specialists in High-Performance Web Scrapers and AI Automation.

***

# Actor input Schema

## `cityNames` (type: `array`):

Filter by city.

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

Filter by category.

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

Start date filter (YYYY-MM-DD).

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

End date filter (YYYY-MM-DD).

## `inStock` (type: `boolean`):

Only return events with tickets still available.

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

Sort results by this field.

## `language` (type: `string`):

Response language.

## `maxResults` (type: `integer`):

Maximum number of events to fetch (1-100).

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

Proxy settings for the scraper.

## Actor input object example

```json
{
  "cityNames": [],
  "categories": [],
  "dateFrom": "",
  "dateTo": "",
  "inStock": false,
  "sort": "DateAsc",
  "language": "de",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("techforce.global/eventim-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("techforce.global/eventim-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call techforce.global/eventim-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=techforce.global/eventim-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventim Scraper — Events, Dates & Ticket Prices for Germany",
        "description": "Extract concerts, shows, and live events from Eventim.de — titles, dates, venues, ticket prices, and availability in bulk. Covers all major German cities. No manual copy-paste. Export ready to CSV, JSON, or Excel in minutes. Built for event agencies, promoters, venue managers, and marketing teams.",
        "version": "1.0",
        "x-build-id": "hxIFa2533TvdYbKPi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techforce.global~eventim-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techforce.global-eventim-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/techforce.global~eventim-scraper/runs": {
            "post": {
                "operationId": "runs-sync-techforce.global-eventim-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/techforce.global~eventim-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-techforce.global-eventim-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "cityNames": {
                        "title": "City names",
                        "type": "array",
                        "description": "Filter by city.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Berlin",
                                "Hamburg",
                                "München",
                                "Köln",
                                "Frankfurt am Main",
                                "Stuttgart",
                                "Düsseldorf",
                                "Dortmund",
                                "Essen",
                                "Leipzig",
                                "Bremen",
                                "Dresden",
                                "Hannover",
                                "Nürnberg",
                                "Duisburg",
                                "Bochum",
                                "Wuppertal",
                                "Bielefeld",
                                "Bonn",
                                "Mannheim",
                                "Karlsruhe",
                                "Wiesbaden",
                                "Münster",
                                "Augsburg",
                                "Gelsenkirchen",
                                "Mönchengladbach",
                                "Braunschweig",
                                "Chemnitz",
                                "Kiel",
                                "Aachen",
                                "Halle",
                                "Magdeburg",
                                "Freiburg im Breisgau",
                                "Krefeld",
                                "Mainz",
                                "Lübeck",
                                "Erfurt",
                                "Oberhausen",
                                "Rostock",
                                "Kassel",
                                "Hagen",
                                "Potsdam",
                                "Saarbrücken",
                                "Hamm",
                                "Ludwigshafen am Rhein",
                                "Mülheim an der Ruhr",
                                "Oldenburg",
                                "Osnabrück",
                                "Leverkusen",
                                "Heidelberg"
                            ]
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Konzerte",
                                "Klassik",
                                "Musical & Show",
                                "Humor",
                                "Sport",
                                "Freizeit",
                                "VIP & Extras"
                            ],
                            "enumTitles": [
                                "Concerts",
                                "Classical",
                                "Musical & Show",
                                "Comedy",
                                "Sports",
                                "Leisure",
                                "Special Tickets / VIP"
                            ]
                        },
                        "default": []
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Start date filter (YYYY-MM-DD).",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "End date filter (YYYY-MM-DD).",
                        "default": ""
                    },
                    "inStock": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only return events with tickets still available.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "DateAsc",
                            "NameAsc",
                            "Rating",
                            "Recommendation"
                        ],
                        "type": "string",
                        "description": "Sort results by this field.",
                        "default": "DateAsc"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "de",
                            "en"
                        ],
                        "type": "string",
                        "description": "Response language.",
                        "default": "de"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of events to fetch (1-100).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
