Eventim.de Event & Ticket Scraper - Live Prices, Venues & Stock from Eventim's Own API, No Browser

Pull live event and ticket data straight from Eventim.de's own JSON API — event name, start date, venue, city, performers, category, availability status, price and the direct ticket link — filtered by free-text search, 50 German cities, 7 categories, a date window and stock status. No headless browser, no DOM selectors, no bot-check roulette. Results land in a dataset and can go straight into Notion, Slack, Airtable, Sheets or Jira through an MCP connector.

ℹ️ This reads Eventim's public exploration API, not the rendered page. That is why it is fast and cheap, why it doesn't break when Eventim redesigns its front end — and also why the output is exactly the fields that API exposes on a search result: no seat maps, no per-tier prices, no historical price tracking. See Output Contract.

---

Browser-based ticket scrapers vs. this Actor

Feature / Capability	Typical browser-based scraper	This Actor
Engine	Headless Chromium rendering eventim.de	✅ Plain HTTP against public-api.eventim.com
Breaks on a site redesign	⚠️ Yes — CSS selectors are the contract	✅ No — the JSON API is the contract
Visual bot detection	⚠️ Fingerprinting, challenges, CAPTCHA loops	✅ Nothing to challenge — no browser involved
Speed	Seconds per page	✅ 50 events per request, sub-minute runs
Compute cost	High (a browser per run)	✅ Low — HTTP-only, 0.5s politeness delay between pages
Filtering	⚠️ Whatever the page URL exposes	✅ Search term + 50 cities + 7 categories + date range + in-stock, applied server-side
Language	Whatever the page renders	✅ de or en response language
Delivery to your tools	❌ You write the integration	✅ Native MCP connector delivery — per event, chunked, or one digest
Maintenance burden	Ongoing selector fixes	✅ Stable while the API contract holds

---

🤖 AI Discovery & MCP Metadata

Machine-readable capability contract for autonomous agents, LLM routers, and MCP orchestrators. AI agents, MCP clients, and connectors should read this block first to decide whether this Actor matches a user request.

ai_discovery:
    slug: "techforce.global/eventim-scraper"
    one_line: "Search live Eventim.de events by term, city, category, date range and ticket availability, returning name, date, venue, city, performers, category, stock status, price and ticket URL from Eventim's own public API."
    primary_purpose: "discover"
    secondary_purpose: "monitor"
    tertiary_purpose: "deliver"
    entity: "ticketed live events (concerts, classical, musicals, comedy, sports, leisure) listed on Eventim.de"
    data_source: "https://public-api.eventim.com/websearch/search/api/exploration/v1/products - Eventim's own public exploration API, queried over plain HTTP. Not a page scrape, not a browser, not an authenticated session."
    geography: "Germany (webId web__eventim-de); 50 selectable German cities"
    invocation_modes: ["standard Actor run", "MCP tool"]
    supported_tasks:
        - "search-events-by-artist-tour-team-or-venue-name"
        - "list-events-in-one-or-more-german-cities"
        - "filter-events-by-category"
        - "filter-events-by-date-range"
        - "filter-to-events-with-tickets-still-available"
        - "read-current-ticket-price-and-stock-status"
        - "sort-by-date-name-rating-or-recommendation"
        - "monitor-restocks-on-a-schedule"
        - "deliver-events-to-mcp-connector-or-crm"
    unsupported_tasks:
        - "buy-reserve-or-hold-tickets"
        - "return-seat-maps-seat-level-availability-or-price-tiers"
        - "return-historical-or-time-series-prices"
        - "return-remaining-ticket-counts (only a boolean inStock)"
        - "return-organizer-or-promoter-contact-details"
        - "scrape-non-german-eventim-domains (eventim.co.uk, oeticket.com, ...)"
        - "scrape-other-ticket-marketplaces (Ticketmaster, StubHub, viagogo)"
        - "return-more-than-100-events-per-run"
        - "log-in-to-an-eventim-account"
    search_keywords:
        - "eventim scraper"
        - "eventim api"
        - "german concert data"
        - "ticket price scraper"
        - "event data germany"
        - "concert listings api"
        - "ticket availability monitor"
        - "eventim.de events"
        - "german event aggregator feed"
        - "live music data germany"
        - "sports event tickets germany"
        - "restock alert tickets"
    synonyms:
        - "eventim.de event scraper"
        - "german ticket data extractor"
        - "concert listing scraper"
        - "eventim ticket monitor"
    related_concepts:
        [
            "event discovery",
            "ticket resale research",
            "pricing intelligence",
            "restock monitoring",
            "event aggregation",
            "venue research",
            "tour tracking",
        ]
    input_entities:
        - "search term (free text)"
        - "city names (50-value enum, multi-select)"
        - "categories (7-value enum, multi-select)"
        - "date range (dateFrom / dateTo)"
        - "in-stock-only toggle"
        - "sort order"
        - "response language (de / en)"
        - "max results (1-100)"
    output_entities:
        [
            "name",
            "type",
            "status",
            "inStock",
            "price",
            "startDate",
            "venue",
            "city",
            "attractions",
            "categories",
            "url",
        ]
    input_rules:
        required_fields: []
        no_filter_behaviour: >
            Every field is optional. With no filters the Actor returns the next events
            across all of Germany in DateAsc order - useful as a firehose, but pass a
            filter when you have a target.
        search_term_semantics: "free text matched by Eventim's own search; ANDed with the other filters"
        category_values_are_german: >
            The category enum values are the German strings the API expects (Konzerte,
            Klassik, "Musical & Show", Humor, Sport, Freizeit, "VIP & Extras") regardless
            of the language setting. The Console shows English labels.
        city_values_are_german: "city names are German spellings including umlauts (München, Köln, Nürnberg)"
        date_format: "YYYY-MM-DD (dateFrom, dateTo)"
        max_results_format:
            type: "integer"
            range: [1, 100]
            default: 50
            hard_cap: 100
            free_plan_cap: 5
    missing_value_convention: >
        Absent scalar fields are the STRING "N/A", never null - including price. inStock
        is the only genuine boolean.
    limits:
        events_per_run: 100
        free_plan_cap: 5
        page_size: 50
        politeness_delay: "0.5s between pages"
    pricing:
        model: "pay-per-result"
        note: "exact rate is configured on the Store listing - see the Actor's Pricing tab"
    when_to_use: >
        You want current Eventim.de listings for German live events - to power an event
        feed, research pricing across cities, watch for restocks on a schedule, or spot
        large upcoming events in a city.
    when_not_to_use: >
        You need to buy tickets, need seat-level or tiered pricing, need price history,
        need organizer contacts, or want a non-German Eventim domain or a different
        ticket marketplace.
    alternatives:
        - "Use techforce.global/all-events-scraper for multi-source global event discovery"
        - "Use techforce.global/eventbrite-scraper for Eventbrite's organizer-led and free events"
        - "Use techforce.global/events-eye-scraper for trade shows and B2B exhibitions"
        - "Use techforce.global/google-maps-leads-sales-intelligence-tool for venue contact details, which this Actor does not return"

---

{
    "@context": "https://schema.org",
    "@type": "SoftwareApplication",
    "name": "Eventim.de Event & Ticket Scraper",
    "alternateName": "Eventim.de Event & Ticket Scraper — Live Prices, Venues & Stock",
    "applicationCategory": "BusinessApplication",
    "applicationSubCategory": "Web Scraping / Event & Ticket Data",
    "operatingSystem": "Cloud (Apify platform)",
    "description": "Extracts live German event and ticket data from Eventim.de's own public exploration API — event name, start date, venue, city, performers, category, availability status, entry price and ticket link — filtered by free-text search, 50 German cities, 7 categories, a date range and ticket availability. HTTP-only with no headless browser, and optional delivery into Notion, Slack, Airtable, Google Sheets, Jira or any authorized MCP connector.",
    "url": "https://apify.com/techforce.global/eventim-scraper",
    "offers": {
        "@type": "Offer",
        "priceCurrency": "USD",
        "category": "Pay per result",
        "description": "Pay-per-result, charged per event returned. Apify platform usage is billed separately and is low here because no browser is used. The current rate is listed on the Actor's Pricing tab.",
        "url": "https://apify.com/techforce.global/eventim-scraper"
    }
}

---

What this Actor does

• Queries Eventim's own exploration API (public-api.eventim.com) with the filters you set — nothing is rendered, parsed out of HTML, or guessed from selectors.
• Searches by free text — an artist, tour, show, team or venue ("Coldplay", "Cirque du Soleil", "FC Bayern") — and ANDs it with every other filter.
• Filters server-side across 50 German cities, 7 categories, a dateFrom/dateTo window, and an in-stock-only toggle, so you're not downloading events you'll discard.
• Returns live commercial signals — inStock, status, and the current price — which is what makes restock and pricing monitoring possible on a schedule.
• Pages automatically at 50 events per request, with a 0.5s pause between pages, until maxResults is reached or Eventim runs out of matches.
• Answers in German or English via the language setting.
• Flattens each product into one clean row: performers and categories comma-joined, venue and city lifted out of the nested location object, price formatted with €.
• Handles aborts gracefully — the ABORTING event is wired, so stopping a run doesn't leave it burning compute.
• Optionally pushes events to an authorized MCP connector (Notion, Slack, Airtable, Sheets, Jira, Linear, or any MCP-compatible connector) as one digest, split into parts, or one call per event. The dataset is always saved regardless of delivery settings.

💡 First time with a connector? Run once with a connector selected. The log prints the connector's available tool names and, right before the first delivery call, the exact input schema that tool expects — so you can fill in Connector tool name and Connector tool arguments from the log instead of by trial and error.

When to use it — and when not to

Scenario	Fit
Powering an event-discovery feed or "what's on" page for German cities	✅ Strong (the core use case)
Restock / availability monitoring on a schedule	✅ Strong — inStock + status, cheap enough to run hourly
Pricing research across cities or categories	✅ Strong — current entry price per event
Tour tracking for one artist across Germany	✅ Strong — searchTerm + no city filter
Spotting large upcoming events in a city (catering, security, transport pitches)	✅ Strong
Venue programming research — what's booked where	✅ Strong
Feeding events into Notion / Airtable / Slack automatically	✅ Strong (deliveryMode)
Buying, reserving or holding tickets	❌ Read-only — never transacts
Seat maps, seat-level availability, price tiers	❌ Not in the search API — one entry price per event
Price history / time series	❌ Each run is a snapshot; build history by scheduling runs and keeping the datasets
How many tickets are left	❌ inStock is a boolean, not a count
Organizer or promoter contact details	❌ Not returned
eventim.co.uk, oeticket.com, other Eventim domains	❌ Hard-wired to web__eventim-de (Germany)
Ticketmaster, StubHub, viagogo	❌ Different platforms entirely
More than 100 events in one run	⚠️ Hard cap of 100 — narrow the filters or run several slices

---

⚡ Execution Rules (Avoid Common Agent Failures)

1. Nothing is required. With no filters at all you get the next events across all of Germany in date order — a valid firehose, but pass searchTerm, cityNames, categories or a date window when you have a target.
2. maxResults is 1–100, default 50, clamped in code as well as in the schema. Free Apify plans are capped at 5 events per run, whatever you ask for — that's a successful run, not a failure.
3. Category values are German strings, even when language: "en". Send "Konzerte", not "Concerts"; "Humor", not "Comedy". The Console shows English labels over German values — an API caller sending the English label gets zero results.
4. City values are German spellings with umlauts — "München", "Köln", "Nürnberg", "Freiburg im Breisgau". "Munich" matches nothing. Send them UTF-8 encoded.
5. Missing values are the string "N/A", not null. That includes price. A price of "N/A" means Eventim published no entry price — it does not mean free. Filter on the string, or coerce before arithmetic.
6. price is a formatted string like "€89.90", not a number, and it is the entry price — the cheapest tier Eventim advertises — not the price of any particular seat.
7. inStock is the only real boolean in the record. It is a yes/no, never a remaining-ticket count.
8. startDate is ISO 8601 with a German offset (e.g. 2026-07-15T20:00:00+02:00). Normalise to UTC before comparing across time zones.
9. attractions and categories are comma-joined strings, not arrays. Split on ", " if you need lists.
10. dateFrom / dateTo are YYYY-MM-DD strings and are not validated by the Actor — a malformed date goes straight to Eventim and the run ends with an HTTP error logged and zero items.
11. An HTTP error ends the fetch loop but the run still SUCCEEDS, with whatever was collected before the failure. Check the log and the item count, not just the run status.
12. Fewer results than maxResults is normal — the filters simply matched less. There is no total-match count in the output.
13. A run is a snapshot. price and inStock are true at request time only; both move constantly on a live ticket platform. Re-run before acting on either.
14. This is Germany only. webId is hard-wired to web__eventim-de; there is no input for other Eventim domains.
15. deliveryMode defaults to summary, not none. That's one connector call per run — but switching to perEvent on a 100-event run makes 100 calls.
16. Use chunked for large sets going to Notion. One call carrying 100 events will hit block-count or timeout limits; chunked splits at ~72,000 characters per call.

dependencies:
    - rule: "no field is required"
      on_violation: "an empty input returns an unfiltered date-ordered firehose"
    - rule: "maxResults is clamped to 100 in code, and to 5 on free Apify plans"
      note: "the schema maximum and the code cap agree at 100; the default is 50"
    - rule: "category enum values are German regardless of the language setting"
      on_violation: "sending 'Concerts' instead of 'Konzerte' returns zero events with no error"
    - rule: "city enum values are German spellings with umlauts"
      on_violation: "'Munich' silently matches nothing - send 'München'"
    - rule: "absent scalars are the string 'N/A', never null - including price"
      on_violation: "null checks pass, numeric parsing of price throws"
    - rule: "price is a formatted string and an entry-level price only"
      on_violation: "treating it as a number, or as the price of a specific seat"
    - rule: "inStock is a boolean, not a remaining-ticket count"
      on_violation: "reporting inventory levels the API never exposes"
    - rule: "an HTTP failure breaks the page loop but the run still SUCCEEDS"
      on_violation: "a partial result set read as complete - check the log"
    - rule: "delivery requires mcpConnector AND mcpTool"
      on_violation: "delivery step is skipped with a warning; the dataset is still written in full"
    - rule: "mcpArguments must reference {message} for the rendered template to appear anywhere"
      on_violation: "message body is empty; the tool is still called"
    - rule: "mcpConnector only resolves when the Actor runs on the Apify platform"
      on_violation: "local runs log 'APIFY_MCP_PROXY_URL is not set' and skip delivery; the dataset is unaffected"
authentication:
    actor_input: none
    platform: "Apify API token required for API / SDK / MCP invocation"
    target_site: "no Eventim account, login or cookie required - and none is accepted"

---

📥 Input Contract

.actor/input_schema.json is authoritative — if any table on this page disagrees with the schema files, the schema files win.

Parameters

Field	Type	Required	Default	Allowed Values / Format	Example
searchTerm	string	⬜ No	""	Free text — artist, tour, show, team or venue	"Coldplay"
cityNames	array	⬜ No	[] (all)	50 German city names — see below	["Berlin","Hamburg"]
categories	array	⬜ No	[] (all)	7 German category values — see below	["Konzerte"]
dateFrom	string	⬜ No	""	YYYY-MM-DD	"2026-09-01"
dateTo	string	⬜ No	""	YYYY-MM-DD	"2026-09-30"
inStock	boolean	⬜ No	false	true = only events with tickets available	true
sort	enum	⬜ No	DateAsc	DateAsc, NameAsc, Rating, Recommendation	"Rating"
language	enum	⬜ No	de	de, en — response language	"en"
maxResults	integer	⬜ No	50	1–100; free plans capped at 5	100
proxyConfiguration	object	⬜ No	{"useApifyProxy": true}	Apify proxy editor object	see below

Empty strings, empty arrays and false are dropped before the request, so an unused filter costs nothing.

categories — all 7 values

Send the value, not the label. The Console shows the label; the API needs the German value.

Value (send this)	Console label	Covers
Konzerte	Concerts	Rock, pop, hip-hop, metal, festivals, tours
Klassik	Classical	Orchestral, opera, recitals, ballet
Musical & Show	Musical & Show	Musicals, stage shows, circus, ice shows
Humor	Comedy	Stand-up, cabaret, Kabarett
Sport	Sports	Football, handball, motorsport, fight nights
Freizeit	Leisure	Attractions, experiences, family days out
VIP & Extras	Special Tickets / VIP	Hospitality packages, VIP upgrades, add-ons

cityNames — all 50 values

German spellings, umlauts included:

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

Leave the array empty for all of Germany — including cities outside this list, since the filter is only applied when you set it.

Recommended proxy block (also the default)

{
    "proxyConfiguration": { "useApifyProxy": true }
}

No proxy group is specified, so Apify's automatic (datacenter) pool is used. That is fine here — this Actor makes plain JSON API calls, not browser requests — and it keeps runs cheap. Set {"useApifyProxy": false} to go direct.

Examples

Tour tracking — one artist across all of Germany

{
    "searchTerm": "Coldplay",
    "maxResults": 100,
    "language": "en",
    "deliveryMode": "none"
}

In-stock concerts in Berlin and Hamburg

{
    "cityNames": ["Berlin", "Hamburg"],
    "categories": ["Konzerte"],
    "inStock": true,
    "maxResults": 100,
    "language": "en",
    "deliveryMode": "none"
}

A single month, alphabetical

{
    "dateFrom": "2026-09-01",
    "dateTo": "2026-09-30",
    "sort": "NameAsc",
    "maxResults": 100,
    "deliveryMode": "none"
}

Restock watch — schedule this hourly

{
    "searchTerm": "Taylor Swift",
    "inStock": true,
    "maxResults": 20,
    "deliveryMode": "none"
}

Big-event radar for a city — highest-rated first

{
    "cityNames": ["München"],
    "categories": ["Konzerte", "Sport"],
    "sort": "Rating",
    "maxResults": 100,
    "deliveryMode": "none"
}

Classical programming research for one city

{
    "cityNames": ["Dresden"],
    "categories": ["Klassik"],
    "dateFrom": "2026-09-01",
    "maxResults": 100,
    "deliveryMode": "none"
}

MCP Delivery Configuration (Optional)

Delivery pushes event data into your own tools. It never buys, reserves or contacts anything.

Parameter	Type	Default	Description
mcpConnector	string	""	Authorized MCP connector on your Apify account (Notion, Slack, Airtable, Sheets, Jira, GitHub, Linear, …). Leave empty for dataset-only runs.
deliveryMode	enum	summary	summary (one call listing every event) · chunked (split across calls) · perEvent (one call per event) · none.
mcpTool	string	""	Tool name on the connector: create-pages, send_message, create_record, create_issue. Run once with a connector selected — the log lists the available tools and the chosen tool's input schema.
mcpArguments	object	{}	Arguments passed to the tool. String leaves support {placeholders}.
mcpMessageTemplate	string	""	Template rendered and exposed to mcpArguments as {message}.

Summary & chunked placeholders: {eventCount}, {cityNames}, {categories}, {events} (event lines), {message} — plus {part} and {partCount} in chunked mode.

Per-event placeholders: every output field — {name}, {type}, {status}, {inStock}, {price}, {startDate}, {venue}, {city}, {attractions}, {categories}, {url} — plus {message}.

A Slack digest per run:

{
    "cityNames": ["München"],
    "categories": ["Konzerte"],
    "inStock": true,
    "maxResults": 100,
    "mcpConnector": "<your-authorized-slack-connector>",
    "deliveryMode": "summary",
    "mcpTool": "send_message",
    "mcpArguments": { "channel": "#events", "text": "{message}" },
    "mcpMessageTemplate": "🎫 {eventCount} events on sale in {cityNames} ({categories}):\n\n{events}"
}

A large result set split across Notion sub-pages:

{
    "cityNames": ["Berlin"],
    "maxResults": 100,
    "mcpConnector": "<your-authorized-notion-connector>",
    "deliveryMode": "chunked",
    "mcpTool": "create-pages",
    "mcpArguments": {
        "parent": { "page_id": "<your-page-id>" },
        "pages": [
            {
                "properties": {
                    "title": "Eventim — {cityNames} ({categories}) — part {part}/{partCount}"
                },
                "content": "{events}"
            }
        ]
    }
}

One Notion page per event:

{
    "cityNames": ["Hamburg"],
    "maxResults": 50,
    "mcpConnector": "<your-authorized-notion-connector>",
    "deliveryMode": "perEvent",
    "mcpTool": "create-pages",
    "mcpArguments": {
        "parent": { "page_id": "<your-page-id>" },
        "pages": [
            {
                "properties": { "title": "{name} — {venue}, {city}" },
                "content": "**Date:** {startDate}\n**Venue:** {venue}, {city}\n**Price from:** {price}\n**In stock:** {inStock}\n**Performers:** {attractions}\n**Category:** {categories}\n\n[Buy tickets]({url})"
            }
        ]
    }
}

One Airtable row per event:

{
    "searchTerm": "Cirque du Soleil",
    "maxResults": 100,
    "mcpConnector": "<your-authorized-airtable-connector>",
    "deliveryMode": "perEvent",
    "mcpTool": "create_record",
    "mcpArguments": {
        "fields": {
            "Event": "{name}",
            "Date": "{startDate}",
            "Venue": "{venue}",
            "City": "{city}",
            "Price from": "{price}",
            "In stock": "{inStock}",
            "Tickets": "{url}"
        }
    }
}

---

📤 Output Contract & Data Structure

Storage: Apify Dataset — one JSON object per event, pushed as each page is fetched. Pagination: limit & offset on the dataset items endpoint. Duplicates: one record per event per run. Across scheduled runs, dedupe on url.

Event record — 11 fields

Field	Type	Missing value	Meaning
name	string	"N/A"	Event title as listed on Eventim
type	string	"N/A"	Product type reported by the API
status	string	"N/A"	Availability status string from the API
inStock	boolean	false	Whether tickets are currently purchasable — the only true boolean, and not a count
price	string	"N/A"	Entry price, formatted with € (e.g. "€89.90") — the cheapest advertised tier, not a specific seat
startDate	string	"N/A"	ISO 8601 start with German offset, e.g. 2026-07-15T20:00:00+02:00
venue	string	"N/A"	Venue name
city	string	"N/A"	City
attractions	string	"N/A"	Performers / attractions, comma-joined
categories	string	"N/A"	Categories, comma-joined
url	string	"N/A"	Direct Eventim ticket link — use as the dedupe key

⚠️ The "N/A" convention matters. Every scalar falls back to the string "N/A" rather than null, so if (event.price) is always truthy and parseFloat(event.price) on a missing price yields NaN. Test for === "N/A" explicitly.

Example dataset item

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

Parsing price safely

def price_eur(event) -> float | None:
    raw = event.get("price", "N/A")
    if raw == "N/A":
        return None                      # no advertised price - NOT free
    return float(raw.lstrip("€").replace(",", ""))

What a successful run looks like

{
    "status": "SUCCEEDED",
    "defaultDatasetId": "<datasetId>",
    "stats": { "itemCount": 50 }
}

itemCount below maxResults is normal — the filters matched fewer events, and there is no total-match count to compare against. itemCount: 0 is a valid empty result. Read the log to tell the causes apart:

Log line	Meaning
No more results at page 1.	The filters genuinely matched nothing — loosen them
Last page reached.	Eventim ran out of matches before maxResults — a complete result set
HTTP error on page N: …	Eventim rejected or failed the request (often a malformed date). Items from earlier pages are still saved
Unexpected error on page N: …	Network / parsing failure; the loop stopped early with a partial set
Free plan detected — capping results to 5.	Free-plan cap applied

---

▶️ Invocation & Integration

Lifecycle: Discover → Understand → Configure → Execute → Retrieve → Validate. Authenticate every call with Authorization: Bearer <APIFY_TOKEN>.

Apify Console

Open the Actor → Input tab → type a Search term and/or pick City names / Categories → optionally set a date window and In stock only → set Max results → (optional) pick an MCP connector, tool and template → Start → export from the Dataset tab (JSON, CSV, Excel, XML).

Model Context Protocol (MCP)

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=techforce.global/eventim-scraper"

Python (apify-client)

import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run = client.actor("techforce.global/eventim-scraper").call(run_input={
    "cityNames": ["Berlin", "Hamburg"],
    "categories": ["Konzerte"],      # German value, not "Concerts"
    "inStock": True,
    "maxResults": 100,               # ceiling; free plans stop at 5
    "language": "en",
    "deliveryMode": "none",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"{len(items)} events")

def price_eur(event):
    raw = event.get("price", "N/A")
    return None if raw == "N/A" else float(raw.lstrip("€").replace(",", ""))

priced = [(e, price_eur(e)) for e in items]
cheapest = sorted((p for p in priced if p[1] is not None), key=lambda p: p[1])[:5]

for event, price in cheapest:
    print(f'€{price:>7.2f}  {event["startDate"][:10]}  {event["name"]}')
    print(f'          {event["venue"]}, {event["city"]}  ·  {event["url"]}')

no_price = sum(1 for _, p in priced if p is None)
print(f'{no_price} events published no entry price (price == "N/A")')

Restock monitoring — schedule this and diff against the last run:

run = client.actor("techforce.global/eventim-scraper").call(run_input={
    "searchTerm": "Taylor Swift",
    "maxResults": 50,
    "deliveryMode": "none",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items

# url is the stable identity; inStock and price are the volatile signals.
snapshot = {e["url"]: (e["inStock"], e["price"]) for e in items}
# Compare against the previous snapshot to detect restocks and price moves.

JavaScript / TypeScript (apify-client)

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("techforce.global/eventim-scraper").call({
    searchTerm: "Cirque du Soleil",
    maxResults: 100,
    language: "en",
    deliveryMode: "none",
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

// "N/A" is a string sentinel, not null - test for it explicitly.
const available = items.filter((e) => e.inStock && e.price !== "N/A");
const byCity = available.reduce<Record<string, number>>((acc, e) => {
    acc[e.city] = (acc[e.city] ?? 0) + 1;
    return acc;
}, {});
console.log(`${available.length} bookable shows`, byCity);

cURL — synchronous run (returns items directly; 300s limit)

curl -X POST \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"searchTerm":"Coldplay","maxResults":50,"language":"en","deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~eventim-scraper/run-sync-get-dataset-items'

cURL — asynchronous with a spend cap (recommended for production)

# 1. Start execution with a hard spend limit
curl -X POST -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"cityNames":["Berlin"],"categories":["Konzerte"],"maxResults":100,"deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~eventim-scraper/runs?maxTotalChargeUsd=0.50'

# 2. Poll
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/actor-runs/<runId>'

# 3. Retrieve when SUCCEEDED
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&format=json'

Scheduling & workflow tools

Monitoring is the strongest use of this Actor: set an Apify schedule (hourly or daily), then consume the dataset from n8n, Make, Zapier or a webhook — or skip the glue entirely and let mcpConnector deliver into Slack or Notion directly.

---

⚠️ Autonomous Agent Error Handling & Resolution Matrix

Error Code	Detection Condition	Underlying Cause	Deterministic Agent Action
AUTH_INVALID	HTTP 401 from Apify	Missing or malformed APIFY_TOKEN	Abort & Prompt User: request a valid Apify API token.
RATE_LIMITED	HTTP 429 from Apify	Apify API rate / concurrency limits	Retry: exponential backoff (2s, 4s, 8s).
SYNC_TIMEOUT	HTTP 408 on the sync endpoint	Run exceeded the 300s synchronous ceiling	Reconfigure: use async POST /runs + polling.
WRONG_CATEGORY_VALUE	SUCCEEDED, 0 items, a category was set	An English label was sent instead of the German value	Modify Input: send Konzerte / Klassik / Humor / Sport / Freizeit / Musical & Show / VIP & Extras.
WRONG_CITY_VALUE	SUCCEEDED, 0 items, a city was set	Anglicised city name (Munich, Cologne, Nuremberg)	Modify Input: use the German spelling with umlauts.
EMPTY_RESULTS	SUCCEEDED, 0 items, log No more results at page 1.	Filters genuinely matched nothing	Modify Input: drop inStock, widen the date range, or remove a city/category.
BAD_DATE_FORMAT	Log HTTP error on page 1 right after setting dates	dateFrom/dateTo not YYYY-MM-DD	Modify Input: fix the format and retry.
PARTIAL_RESULTS	SUCCEEDED, log has HTTP error on page N with N > 1	The fetch loop broke mid-way; earlier pages were saved	Retry the same input; treat the set as incomplete meanwhile.
FREE_PLAN_CAP	itemCount stops at 5, upgrade banner in the log	Free Apify plan caps the run at 5 events	Prompt User: upgrade for full-volume runs.
SIZE_CLAMPED	Asked for more than 100, got 100	maxResults is hard-capped at 100	Reconfigure: slice the query by city, category or date window.
NO_TOTAL_COUNT	Agent wants to know how many events matched	The API's total is not exposed in the output	Fix Expectation: page until a short page returns.
NA_NOT_NULL	Null checks pass but values are unusable	Absent scalars are the string "N/A"	Fix Code: compare against "N/A" explicitly.
PRICE_NOT_NUMERIC	NaN from arithmetic on price	price is "€89.90" or "N/A"	Fix Code: strip €, and handle "N/A" as unknown — not as free.
PRICE_MISREAD_AS_SEAT	Quoted price doesn't match checkout	price is the cheapest advertised tier	Fix Expectation: describe it as "from €X".
STOCK_COUNT_EXPECTED	User wants tickets remaining	inStock is a boolean	Fix Expectation: availability yes/no only.
STALE_SNAPSHOT	Price / availability differ from the site	A run is a point-in-time snapshot	Re-run before acting; schedule for monitoring.
TZ_MISMATCH	Off-by-hours date comparisons	startDate carries a German UTC offset	Fix Code: parse as ISO 8601 and normalise to UTC.
WRONG_DOMAIN	User asked about eventim.co.uk / oeticket	webId is hard-wired to web__eventim-de	Abort & Prompt User: German Eventim only.
WRONG_PLATFORM	User asked about Ticketmaster / StubHub	Different marketplace	Re-route: a platform-specific Actor.
NO_SEAT_DATA	No seat map or price tiers	Not exposed by the search API	Fix Expectation: open url for seat-level detail.
NO_ORGANIZER_CONTACT	No promoter email or phone	Not returned	Re-route: Google Maps Business Leads for venue contacts.
DELIVERY_SKIPPED	Log no tool name was provided	mcpConnector set but mcpTool empty	Modify Input: set mcpTool; the dataset is already saved.
DELIVERY_TOOL_UNKNOWN	Log Tool 'x' is not available on this connector	Wrong tool name for that connector	Modify Input: pick a name from the Available tools: list in the same log line.
DELIVERY_ARGS_INVALID	Connector rejects the arguments	mcpArguments doesn't match the tool's schema	Read the log: the line Connector tool schema -> … prints the exact expected shape.
DELIVERY_EMPTY	Connector called, body empty	mcpArguments omitted the {message} placeholder	Modify Input: map {message} inside mcpArguments.
DELIVERY_FLOOD	Up to 100 connector calls per run	deliveryMode was set to perEvent	Reconfigure: use summary or chunked.
DELIVERY_TIMEOUT	Notion / Airtable times out on one call	One payload carrying every event is too large	Reconfigure: deliveryMode: "chunked".
MCP_PROXY_MISSING	Log APIFY_MCP_PROXY_URL is not set	Running locally instead of on the platform	Reconfigure: apify push and run on the platform.
CHARGE_LIMIT	Run aborted before maxResults reached	maxTotalChargeUsd spend threshold reached	Prompt User: confirm a higher spend cap.

Reading run status: a wrong enum value returns zero items with no error — the run still finishes SUCCEEDED, so an empty dataset is far more often a German spelling problem than a fault. Only a FAILED status is a platform-level failure. Every Eventim-side and field-level row in the table above comes from this Actor’s own source; the 401/408/429 rows are standard Apify API responses.

---

🗣️ Natural Language → Actor Mapping

User says	Intent	Constructed Actor input
"When is Coldplay playing in Germany?"	Tour tracking	{"searchTerm":"Coldplay","maxResults":100,"language":"en"}
"What concerts are on in Berlin?"	City discovery	{"cityNames":["Berlin"],"categories":["Konzerte"],"maxResults":100}
"Any tickets still available for that show?"	Availability	{"searchTerm":"<show>","inStock":true,"maxResults":20}
"What's on in Munich next month?"	Date window	{"cityNames":["München"],"dateFrom":"<1st>","dateTo":"<last>","maxResults":100}
"Cheapest classical concerts in Dresden"	Price research	{"cityNames":["Dresden"],"categories":["Klassik"],"maxResults":100} then sort on parsed price
"Big sports events coming up in Cologne"	Event radar	{"cityNames":["Köln"],"categories":["Sport"],"sort":"Rating","maxResults":100}
"Alert me when this show restocks"	Monitoring	schedule {"searchTerm":"<show>","inStock":true} hourly + deliveryMode:"summary" to Slack
"Comedy shows in Hamburg this autumn"	Category + date	{"cityNames":["Hamburg"],"categories":["Humor"],"dateFrom":"<start>","dateTo":"<end>"}
"Compare ticket prices across German cities"	Pricing intelligence	one run per city, same categories, then compare parsed price
"Everything at the Olympiastadion"	Venue research	{"searchTerm":"Olympiastadion","maxResults":100}
"Musicals I could take the family to"	Family / leisure	{"categories":["Musical & Show","Freizeit"],"inStock":true,"maxResults":100}
"Push tonight's events into Notion"	Delivery	{"dateFrom":"<today>","dateTo":"<today>","mcpConnector":"notion","deliveryMode":"chunked","mcpTool":"create-pages"}
"Buy me two tickets"	Transaction	❌ Read-only — open url to purchase
"Which seats are left, and what do they cost?"	Seat detail	❌ Not exposed — entry price only; open url
"How many tickets are left?"	Inventory	❌ inStock is a yes/no, not a count
"Show me the price history for this tour"	Time series	⚠️ Not stored — schedule runs and keep the datasets to build it
"Same thing for London"	Wrong domain	❌ German Eventim only
"Check Ticketmaster too"	Wrong platform	❌ Different marketplace
"Who's the promoter, and how do I reach them?"	Contact data	❌ Not returned

Should NOT route here: buying, reserving or holding tickets · seat maps, seat-level availability or price tiers · ticket counts remaining · price history or time-series data · organizer / promoter contact details · non-German Eventim domains (eventim.co.uk, oeticket.com) · other marketplaces (Ticketmaster, StubHub, viagogo) · resale or secondary-market listings · more than 100 events in one run.

---

🧭 Agent Execution & Routing Logic

[Input User Query]
       │
       ▼
1. Is this about ticketed live events on GERMAN Eventim?   NO  → Abort / route elsewhere
       │ YES                                                    (other domains and marketplaces are out of scope)
       ▼
2. Does the user want to TRANSACT (buy / reserve / hold)?  YES → Abort. Read-only. Hand them the `url`
       │ NO
       ▼
3. Do they need seat maps, price tiers, ticket counts, price history, or promoter contacts?
       │ YES → Abort with the reason; none are exposed by the search API
       │ NO
       ▼
4. Pick the anchor:
       ├── a named artist / tour / show / team / venue → searchTerm
       ├── "what's on in <city>"                       → cityNames (GERMAN spelling)
       ├── a kind of event                             → categories (GERMAN value, not the label)
       └── a time window                               → dateFrom / dateTo (YYYY-MM-DD)
       ▼
5. Only bookable events matter?  YES → inStock: true
       ▼
6. Choose sort: DateAsc (what's next) · NameAsc (catalogue) · Rating / Recommendation (biggest first)
       ▼
7. Set maxResults ≤ 100 (default 50, free plans 5). Need more? slice by city / category / date
       ▼
8. One-off, or monitoring?
       ├── one-off     → single run
       └── monitoring  → Apify schedule + deliveryMode "summary" to Slack; diff on `url`
       ▼
9. Deliver to a connector? YES → mcpConnector + mcpTool + {message}
       │                          summary (1 call) / chunked (large sets) / perEvent (≤100 calls)
       │ NO  → set deliveryMode "none" (it defaults to summary)
       ▼
[Execute]
       │
       ├──► SUCCEEDED, items > 0 ──► handle the data contract:
       │        "N/A" is a STRING sentinel, not null - test for it
       │        price = "€89.90" string, entry-level tier - strip € before arithmetic
       │        inStock is boolean, not a count
       │        startDate carries a German offset - normalise to UTC
       │        attractions / categories are comma-joined strings, not arrays
       │        dedupe on `url`
       │        log has "HTTP error on page N"? → the set is PARTIAL
       │
       └──► SUCCEEDED, items == 0 ──► READ THE LOG:
                "No more results at page 1."   → filters too narrow, or a WRONG ENUM VALUE
                                                  (English category label / anglicised city)
                "HTTP error on page 1: ..."    → likely a malformed date

---

💰 Cost Control & Pricing Transparency

Pay-per-result: you are charged per event returned, with no monthly subscription. The exact rate is on the Actor's Pricing tab in the Apify Store.

Free Apify plans are capped at 5 events per run, so you can validate a filter set — and confirm your category and city values are the German ones — for the cost of five results before committing to a full sweep.

Autonomous spend caps: pass maxTotalChargeUsd as a query parameter on the run endpoint for a hard per-execution ceiling.

ℹ️ Always confirm the live rate on the Actor’s Pricing tab before committing to a large run. The Store listing is what bills you. Platform usage is charged on top, but it is unusually low for this Actor because it makes plain HTTP calls rather than driving a browser.

Platform usage is billed on top at your plan's rates — and this is where this Actor is unusually cheap. It is HTTP-only, with no browser, so a 100-event run is two API requests plus a 0.5s pause, finishing in seconds. Proxy traffic is JSON, not page assets, so datacenter proxy is enough; there's no residential-GB cost of the kind browser scrapers incur.

Cost levers:

• Validate at maxResults: 5 first. A wrong category value (English label instead of German) costs you a run either way — better a 5-result one.
• Set maxResults to what you'll use. The default is 50 and the ceiling is 100.
• Use inStock: true for monitoring so you're not paying for sold-out events you'd filter out anyway.
• Prefer summary/chunked delivery over perEvent — 1 connector call instead of up to 100.
• For scheduled monitoring, keep maxResults tight. An hourly restock watch on 20 events costs a fraction of an hourly 100-event sweep, and tracks the same signal.
• Cap the spend with maxTotalChargeUsd on any agent-driven run.

---

🔍 Companion machine-readable files

File	Purpose
.actor/actor.json	Identity, title, version, build tag, and the input / output / dataset schema references
.actor/input_schema.json	Authoritative typed input contract — search term, the 50-city and 7-category enums, date range, stock toggle, sort, language, maxResults (1–100), proxy, and the 5 delivery fields
.actor/dataset_schema.json	Console Output tab view — event, city, venue, date, price, in-stock, link
.actor/output_schema.json	Declares where results are stored
my_actor/main.py	Query building, paged API fetching, product normalisation, free-plan cap, abort handling, MCP delivery
my_actor/connector.py	MCP connector session handling through the Apify MCP Proxy, plus describe_tool() — which is what logs a tool's expected argument shape

Note: this Actor has no pay_per_event.json and makes no Actor.charge() calls — billing is configured entirely on the Store listing.

If any table on this page disagrees with the schema files, the schema files win.

---

🛠️ Troubleshooting

#	Symptom you see	Most likely cause	Fix
1	0 items, and you set a category	You sent the English label (Concerts) instead of the German value (Konzerte)	Send the value from the category table.
2	0 items, and you set a city	Anglicised name (Munich, Cologne)	Use the German spelling — München, Köln.
3	0 items with a date filter	Malformed date, or the window is genuinely empty	Use YYYY-MM-DD; check the log for HTTP error on page 1.
4	0 items with inStock: true	Everything matching is sold out	Drop inStock to see sold-out events too.
5	Exactly 5 events every run	Free Apify plan cap	Upgrade the plan; the log prints the upgrade banner.
6	Asked for 500, got 100	maxResults is hard-capped at 100	Slice by city, category or date window.
7	Fewer events than maxResults	The filters matched fewer, or Last page reached.	Expected — there is no total-match count to compare with.
8	Results stop abruptly mid-run	Log shows HTTP error on page N — the loop broke	Retry; treat the current set as partial.
9	price is "N/A"	Eventim published no entry price for that event	Not free. Treat as unknown and open url.
10	parseFloat(price) gives NaN	price is "€89.90" — a formatted string	Strip € first; handle "N/A" separately.
11	Quoted price doesn't match checkout	price is the cheapest advertised tier	Present it as "from €X".
12	Null checks never fire	Missing scalars are the string "N/A"	Compare against "N/A" explicitly.
13	attractions / categories won't iterate	They're comma-joined strings	split(", ").
14	Dates look shifted by an hour or two	startDate carries a German UTC offset	Parse as ISO 8601, normalise to UTC.
15	Price or availability differs from the site	A run is a point-in-time snapshot	Re-run; schedule for monitoring.
16	No seat map or price tiers	Not exposed by the search API	Open url for seat-level detail.
17	No organizer or promoter contact	Not returned	Pair with Google Maps Business Leads for the venue.
18	Wanted eventim.co.uk / oeticket.com	webId is hard-wired to German Eventim	Out of scope for this Actor.
19	Up to 100 connector calls per run	deliveryMode: "perEvent"	Switch to summary or chunked.
20	Notion / Airtable timed out	One call carrying every event is too large	Use deliveryMode: "chunked".
21	Connector rejected the arguments	mcpArguments doesn't match the tool's schema	Read the Connector tool schema -> … log line — it prints the exact expected shape.
22	Slack / Notion received nothing	Delivery needs both mcpConnector and mcpTool	Set both. The dataset is still written in full.
23	Connector fired but the message body is empty	mcpArguments did not reference {message}	Map {message} in mcpArguments and populate mcpMessageTemplate.
24	Log APIFY_MCP_PROXY_URL is not set	You ran locally; connectors only resolve on the platform	Deploy with apify push and run on the platform.
25	HTTP 408 on run-sync-get-dataset-items	The synchronous endpoint has a hard 300-second ceiling	Use async POST /runs → poll → fetch.
26	HTTP 401 / 403 from Apify	Missing, expired or malformed APIFY_TOKEN	Regenerate in Apify Console → Settings → API & Integrations.
27	HTTP 429 from Apify	Apify account concurrency / rate limits	Retry with exponential backoff (2s → 4s → 8s).

Diagnostic checklist before opening an issue

1. Baseline run. {"cityNames":["Berlin"],"maxResults":5,"deliveryMode":"none"} — no category, no dates, no stock filter.
2. Items returned? If yes, the pipeline is fine and one of your filters was the problem — re-add them one at a time.
3. Suspect an enum first. A wrong category label or an anglicised city name returns zero items with no error at all — that's the single most common cause.
4. Check the log line. No more results at page 1. means the filters matched nothing; HTTP error on page 1 means Eventim rejected the request (usually a date).
5. Confirm maxResults. Exactly 5 items on every run means you're on a free plan, not that the filters are wrong.

If the issue survives all five steps, open an Issues ticket on the Actor page (or email support) with the run ID and the exact input JSON.

❓ FAQ

Setup & access

Do I need an Eventim account or login?

No — and none is accepted. The Actor reads Eventim's public exploration API, the same one their own search front end calls.

Is this scraping the Eventim website?

Not in the usual sense. There's no browser and no HTML parsing: it makes plain HTTP requests to public-api.eventim.com and reads JSON. That's why it's fast, cheap, and stable against front-end redesigns.

Can I plug it into Claude, Cursor, or a LangChain agent?

Yes — it is a native MCP tool:

claude mcp add --transport http apify "https://mcp.apify.com?tools=techforce.global/eventim-scraper"

Does it work for eventim.co.uk, oeticket.com, or other Eventim sites?

No. The webId is hard-wired to web__eventim-de, so this is the German platform only.

Filtering

Why did my search return nothing?

By far the most common cause is an enum value: the categories are German strings (Konzerte, not Concerts) and the cities are German spellings (München, not Munich). A wrong value returns zero items with no error message.

Do I have to pick a city?

No. Leave cityNames empty for all of Germany — including cities outside the 50-value list, since the filter only applies when you set it.

Can I search for one artist across the whole country?

Yes — that's searchTerm with no city filter. It's the best way to map a tour.

Does language: "en" translate the category filter too?

No. language affects the response text; the category filter values stay German either way.

Prices & availability

Is price the price I'll pay?

It's the entry price — the cheapest tier Eventim advertises for that event. Actual checkout depends on seat, fees and tier, so present it as "from €X".

What does price: "N/A" mean?

Eventim published no entry price for that event. It does not mean free.

Does inStock tell me how many tickets are left?

No — it's a boolean. The API exposes availability, not inventory levels.

Can I get seat maps or price tiers?

No. Open the event's url for seat-level detail.

Can I track how prices change over time?

Not from one run — each run is a snapshot. Schedule runs and keep the datasets, then diff on url; that's the standard way to build price and restock history.

Output & scope

Why is everything "N/A" instead of null?

That's the Actor's missing-value convention for every scalar field. Test === "N/A" rather than relying on null checks.

Why are attractions and categories strings and not arrays?

They're comma-joined for direct use in a spreadsheet or CRM cell. split(", ") to get lists back.

Can I get the organizer's or promoter's contact details?

No — the search API doesn't expose them.

Pricing

How is this billed?

Pay-per-result — you're charged per event returned, with no monthly subscription. The current rate is on the Actor's Pricing tab. Apify platform usage is billed separately, and it's low here because there's no browser.

How do I guarantee an agent never overspends?

Pass maxTotalChargeUsd as a query parameter on the run endpoint, and validate filters at maxResults: 5 first.

---

🔗 Related Actors

Event data, by source

Each of these covers a different slice of the event world. Pick by where the events are listed, not by the kind of event.

Actor	Source	Best for	Why pick it over this one
This Actor	Eventim.de's own API	German ticketed live events	Live price and stock signals, 50 cities, HTTP-only speed
All Events Scraper	allevents.in	Global, multi-city event discovery	Coverage far beyond Germany and beyond ticketed shows
Eventbrite Scraper	eventbrite.com	Organizer-led events, meetups, free events, workshops	Eventim carries very little of this long tail
Events Eye Scraper	eventseye.com	Trade shows, B2B exhibitions, conferences	Professional events, not consumer entertainment

ℹ️ Complementary, not competing. Eventim is where the big ticketed tours live; Eventbrite is where the grassroots long tail lives; Events Eye is B2B. For a genuinely complete "what's on in Berlin" feed, run several and dedupe on name + date + venue.

Enrichment & downstream pipeline

Actor	Use it for
Google Maps Business Leads & Sales Intelligence	Venue contact details — email, phone, website — which this Actor never returns
Hospitality Lead Scraper	Bars, hotels and restaurants near a venue, for event-driven local outreach
Advanced Website Crawling Actor	Crawl a venue's or promoter's own site alongside the Eventim listing
GOV.UK Business Scraper	Verify a UK promoter or venue operator against Companies House

Suggested pipeline patterns

🔔 Restock alert bot Hourly schedule, inStock: true, tight maxResults → deliveryMode: "summary" into a Slack channel → diff on url to fire only on state changes.

📅 "What's on" feed Daily run per city → deliveryMode: "chunked" into Notion → a self-maintaining event page per city.

📊 Pricing intelligence across cities One run per city with identical categories → parse price → compare entry prices for the same tour across Germany.

🎯 Event-driven local sales This Actor for large upcoming events in a city → Google Maps Business Leads or Hospitality Lead Scraper for nearby venues → pitch catering, transport, security or accommodation ahead of the date.

🌍 Complete city coverage This Actor + All Events Scraper + Eventbrite Scraper → dedupe on name + date + venue → ticketed tours and the grassroots long tail in one feed.

Browse all Actors by Techforce Global at scraper.techforce.global.

---

🔐 Compliance & Data Privacy

This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Eventim, CTS EVENTIM AG & Co. KGaA, or any venue, promoter or artist named in its output. All trademarks are the property of their respective owners.

It reads publicly available event listings from Eventim's own public API. It does not log in, does not accept credentials, and does not access anything behind authentication. It never buys, reserves or holds tickets.

The output is commercial event data, not personal data — event names, venues, cities, dates, prices, availability. Performer names in attractions are stage and act names published commercially, not private personal information, so the GDPR exposure here is minimal compared with a contact-data scraper. Two things still apply:

• Pricing and availability are volatile and time-stamped by the run, not by Eventim. Republishing them as current — in an app, a newsletter or an aggregator — means committing to a refresh cadence. Stale prices shown to consumers can create obligations under consumer-protection and price-transparency rules (in Germany, the UWG and Preisangabenverordnung); always attribute the source and link through to url for the live price.
• Automated ticket buying is regulated, and this Actor doesn't do it. Germany and other jurisdictions restrict automated purchasing and resale of tickets. This Actor is strictly read-only; if you build resale or bulk-purchase tooling downstream, that's your compliance obligation, not something this Actor performs or enables directly.

You remain responsible for ensuring your use complies with Eventim's terms of service, applicable data-protection law (GDPR / UK GDPR / CCPA), and consumer-protection and ticketing rules in the markets you operate in.

---

🆘 Support & Custom Pipeline Engineering

Need multi-city batch runs, scheduled refreshes with change detection, price-history warehousing, or a full event-intelligence pipeline?

• Email: bhavin.shah@techforceglobal.com
• Custom Enterprise Integrations: Book a 15-Minute Technical Consultation
• Maintained by: Techforce Global — Specialists in High-Performance Web Scrapers and Agentic Workflows.

---

Made with ❤️ by Techforce Global Specialists in High-Performance Web Scrapers and AI Automation.

---

🏷️ Structured data for search & AI discovery

SoftwareApplication describes the Actor; FAQPage wraps the FAQ above so those answers are eligible for rich results, matching it question-for-question.

{
    "@context": "https://schema.org",
    "@type": "SoftwareApplication",
    "name": "Eventim.de Event & Ticket Scraper",
    "alternateName": "Eventim.de Event & Ticket Scraper — Live Prices, Venues & Stock",
    "applicationCategory": "BusinessApplication",
    "applicationSubCategory": "Web Scraping / Event & Ticket Data",
    "operatingSystem": "Cloud (Apify platform)",
    "description": "Extracts live German event and ticket data from Eventim.de's own public exploration API — event name, start date, venue, city, performers, category, availability status, entry price and ticket link — filtered by free-text search, 50 German cities, 7 categories, a date range and ticket availability. HTTP-only with no headless browser, and optional delivery into Notion, Slack, Airtable, Google Sheets, Jira or any authorized MCP connector.",
    "url": "https://apify.com/techforce.global/eventim-scraper",
    "author": {
        "@type": "Organization",
        "name": "Techforce Global",
        "url": "https://www.techforceglobal.com"
    },
    "provider": {
        "@type": "Organization",
        "name": "Apify",
        "url": "https://apify.com"
    },
    "offers": {
        "@type": "Offer",
        "priceCurrency": "USD",
        "category": "Pay per result",
        "description": "Pay-per-result, charged per event returned. Apify platform usage is billed separately and is low here because no browser is used. The current rate is listed on the Actor's Pricing tab.",
        "url": "https://apify.com/techforce.global/eventim-scraper"
    },
    "featureList": [
        "No Eventim account, API key or credentials required or accepted",
        "Reads Eventim's own public exploration API - no headless browser and no HTML parsing",
        "Stable against front-end redesigns, and cheap in platform usage as a result",
        "Free-text search across artists, tours, shows, teams and venues",
        "50 German cities and 7 categories as dropdown filters, combined with AND",
        "Date-range filtering and an in-stock-only toggle",
        "Four sort orders including date, name, rating and recommendation",
        "German or English response language",
        "Entry price per event, presented as the cheapest advertised tier",
        "Ticket availability as a boolean status, straight from the API",
        "Direct ticket link on every row as the stable identity for diffing runs",
        "Graceful abort handling, so a stopped run keeps everything already collected",
        "Optional MCP delivery to Notion, Slack, Airtable, Google Sheets, Jira and more",
        "Chunked delivery mode keeps long event lists under connector size and timeout caps"
    ],
    "isAccessibleForFree": false,
    "softwareRequirements": "Apify account and API token",
    "softwareHelp": {
        "@type": "CreativeWork",
        "url": "https://apify.com/techforce.global/eventim-scraper"
    },
    "keywords": "Eventim scraper, Eventim.de, German event data, ticket availability, ticket price monitoring, concert data, event calendar, venue data, ticket restock alerts, price tracking, MCP connector"
}

{
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
        {
            "@type": "Question",
            "name": "Do I need an Eventim account or login?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No - and none is accepted. The Actor reads Eventim's public exploration API, the same one their own search front end calls."
            }
        },
        {
            "@type": "Question",
            "name": "Is this scraping the Eventim website?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Not in the usual sense. There is no browser and no HTML parsing: it makes plain HTTP requests to public-api.eventim.com and reads JSON. That is why it is fast, cheap, and stable against front-end redesigns."
            }
        },
        {
            "@type": "Question",
            "name": "Can I plug it into Claude, Cursor, or a LangChain agent?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Yes - it is a native MCP tool. Add it with: claude mcp add --transport http apify \"https://mcp.apify.com?tools=techforce.global/eventim-scraper\""
            }
        },
        {
            "@type": "Question",
            "name": "Does it work for eventim.co.uk, oeticket.com, or other Eventim sites?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. The webId is hard-wired to web__eventim-de, so this is the German platform only."
            }
        },
        {
            "@type": "Question",
            "name": "Why did my search return nothing?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "By far the most common cause is an enum value: the categories are German strings (Konzerte, not Concerts) and the cities are German spellings (München, not Munich). A wrong value returns zero items with no error message."
            }
        },
        {
            "@type": "Question",
            "name": "Do I have to pick a city?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Leave cityNames empty for all of Germany - including cities outside the 50-value list, since the filter only applies when you set it."
            }
        },
        {
            "@type": "Question",
            "name": "Can I search for one artist across the whole country?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Yes - that is searchTerm with no city filter. It is the best way to map a tour."
            }
        },
        {
            "@type": "Question",
            "name": "Does language \"en\" translate the category filter too?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. language affects the response text; the category filter values stay German either way."
            }
        },
        {
            "@type": "Question",
            "name": "Is price the price I'll pay?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "It is the entry price - the cheapest tier Eventim advertises for that event. Actual checkout depends on seat, fees and tier, so present it as from that amount."
            }
        },
        {
            "@type": "Question",
            "name": "What does price \"N/A\" mean?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Eventim published no entry price for that event. It does not mean free."
            }
        },
        {
            "@type": "Question",
            "name": "Does inStock tell me how many tickets are left?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No - it is a boolean. The API exposes availability, not inventory levels."
            }
        },
        {
            "@type": "Question",
            "name": "Can I get seat maps or price tiers?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No. Open the event's url for seat-level detail."
            }
        },
        {
            "@type": "Question",
            "name": "Can I track how prices change over time?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Not from one run - each run is a snapshot. Schedule runs and keep the datasets, then diff on url; that is the standard way to build price and restock history."
            }
        },
        {
            "@type": "Question",
            "name": "Why is everything \"N/A\" instead of null?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "That is the Actor's missing-value convention for every scalar field. Test for the string N/A rather than relying on null checks."
            }
        },
        {
            "@type": "Question",
            "name": "Why are attractions and categories strings and not arrays?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "They are comma-joined for direct use in a spreadsheet or CRM cell. Split on the comma and space to get lists back."
            }
        },
        {
            "@type": "Question",
            "name": "Can I get the organizer's or promoter's contact details?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "No - the search API does not expose them."
            }
        },
        {
            "@type": "Question",
            "name": "How is this billed?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Pay-per-result - you are charged per event returned, with no monthly subscription. The current rate is on the Actor's Pricing tab. Apify platform usage is billed separately, and it is low here because there is no browser."
            }
        },
        {
            "@type": "Question",
            "name": "How do I guarantee an agent never overspends?",
            "acceptedAnswer": {
                "@type": "Answer",
                "text": "Pass maxTotalChargeUsd as a query parameter on the run endpoint, and validate filters at maxResults 5 first."
            }
        }
    ]
}