# Eventbrite Scraper - Events, Ticket Prices & Availability (`s-r/eventbrite-events`) Actor

Search Eventbrite events by city, category and date. Export event titles, local dates with time zones, venues, organizers, ticket price ranges and availability as one row per event.

- **URL**: https://apify.com/s-r/eventbrite-events.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 events

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Eventbrite Scraper

Eventbrite Scraper collects public event listings by city, category and date. Get a structured row for each event, including its venue, organizer, ticket price range and current availability. Use the results to prepare local event calendars, plan hospitality campaigns, research competing events or compare advertised prices across categories.

The scraper searches physical events around a named city or coordinates, or online events without a physical location. It returns the information that Eventbrite publishes in its event listings. Prices and availability describe the time of collection and can change as an organizer updates an event or tickets sell out.

### Eventbrite Scraper input

Choose exactly one way to define your location. Use `location` for a city name such as Amsterdam or a canonical Eventbrite location slug. Use `place_id` when you already know the numeric Eventbrite place identifier. Alternatively, provide both `latitude` and `longitude`; `radius_km` then controls the search distance and defaults to ten kilometres. Set `online_only` to true to collect online events instead of selecting a physical place.

The `category` option accepts Eventbrite categories such as music, business, food-and-drink, arts, health and community. Leave it out to search all categories. A category describes Eventbrite's classification and does not guarantee a particular topic inside every event description.

Use `date_preset` for today, tomorrow, this weekend, this week, next week, this month or next month. The default, any, includes current and future events. An event that has already started can still appear when it runs across multiple days. For an explicit period, provide both `start_date` and `end_date` in YYYY-MM-DD format and keep the date preset at any. The end date is inclusive.

The `price` option selects any, free or paid events. The `keyword` option is a ranking hint: Eventbrite can return listings that do not contain the supplied text. It should not be used as an exact text filter. Choose `sort` date for chronological ordering, or keep relevance ordering. Ongoing events can appear before events that have yet to start.

Set `max_items` to the maximum number of unique events you want, from one to one thousand. The default is fifty. The limit applies to the whole collection, including any continuation requests, rather than restarting on each page. On the free plan, collection is capped at ten events.

An input used for a real Amsterdam collection is:

```json
{"location":"Amsterdam","category":"music","max_items":10}
```

### Output and event fields

Each dataset row has `event_id`, `title`, `url`, `source`, `platform` and `fetched_at`. Use the Eventbrite event ID when joining repeated collections. Titles and summaries remain in the language supplied by the organizer; the scraper does not translate them.

Dates include the local start date, local start and end times, the IANA time zone, complete timestamps with UTC offsets, and corresponding UTC timestamps. The offset is calculated for the event date, so a future winter event and a summer event can have different offsets in the same city.

Venue fields include the venue name, street address, city, region, postal code, country code and numeric coordinates when Eventbrite provides them. Online events normally have no venue; those fields remain null. Organizer fields include the public name, profile URL, identifier and follower count when available. Category, subcategory, event format, organizer tags and an image link are also included.

Ticket information includes `price_min`, `price_max`, `currency`, `is_free`, `is_sold_out` and `tickets_available`. Prices are amounts in the stated currency, not cents. For example, a real listing for The Eminem Experience in Amsterdam advertised a minimum of 23.90 EUR and a maximum of 28.34 EUR, starting on 27 February 2027 at 18:00 in Europe/Amsterdam. This is an observed listing example, not a promise about future pricing.

A zero price on a paid event is treated as unknown and returned as null. The unfiltered amount is available in `price_min_raw` or `price_max_raw`. Availability flags are separate: an event can have no available tickets without being marked sold out. The raw `sales_status` can also say on_sale for a sold-out event. Keep those fields separate in your downstream calculations.

### Pricing

Usage is counted per delivered event. Consult the actor's current pricing panel for the applicable price before running a collection. Empty searches have no event charge, and this product defines no separate start event. Duplicate event IDs within a collection are delivered once and count once. The free plan is limited to ten returned events; a larger requested limit does not bypass that cap.

### Limits and interpretation

Eventbrite exposes at most one thousand events for one search. A larger matching catalogue does not mean all matches can be collected with that search. Narrow the date range or category and make separate requests when you need wider coverage. The total count can be unknown when Eventbrite reports a rounded or capped number.

Collection can return `partial` with a continuation token if an unfinished request needs another step. The actor follows that continuation automatically within its run budget. Direct API users should repeat the original input with the returned cursor. Review warnings when completeness matters, and retain the event ID for comparisons between separate runs.

Ticket prices are advertised ranges, not a breakdown of every ticket class. Whether the displayed price includes booking fees depends on the organizer, and the listings do not establish that consistently. Final checkout prices, private attendee details, account-only information and full descriptions are outside this scraper's scope. Recurring event instances may be grouped by Eventbrite; `dedup_count` reports the grouping when available.

### FAQ

#### Can I search for online events?

Yes. Set `online_only` to true and omit the city, place ID and coordinates. Category, period, price and ranking options still apply. Venue fields remain null where Eventbrite supplies no physical venue.

#### Why is a paid event's minimum price null?

Eventbrite sometimes advertises a zero minimum for an unavailable paid event. Returning null avoids implying that a free ticket is available. Check the raw price and the independent availability flags for the original source information.

#### Does keyword search require an exact match?

No. Eventbrite uses the keyword to rank results and may include events without that text. Apply your own title, summary or tag filter after collection if exact matching is necessary.

#### How do I handle an ambiguous city name?

Eventbrite chooses the matching location. Inspect the `resolved_place` record in the run’s key-value store when searching by city name, or provide a known place ID or coordinates for a more explicit location.

# Actor input Schema

## `location` (type: `string`):

City name or Eventbrite location slug. Choose exactly one location method.

## `place_id` (type: `string`):

Eventbrite numeric place ID; skips city resolution.

## `latitude` (type: `number`):

Latitude of the search centre; requires longitude.

## `longitude` (type: `number`):

Longitude of the search centre; requires latitude.

## `radius_km` (type: `integer`):

Radius in kilometres for coordinates only; defaults to 10 when omitted.

## `online_only` (type: `boolean`):

Search online events instead of a physical location.

## `category` (type: `string`):

Optional Eventbrite category.

## `date_preset` (type: `string`):

Date window; any means current and future events, including ongoing events.

## `start_date` (type: `string`):

Inclusive local date YYYY-MM-DD; requires end_date and date_preset any.

## `end_date` (type: `string`):

Inclusive local end date YYYY-MM-DD; requires start_date.

## `price` (type: `string`):

Filter by free or paid events.

## `keyword` (type: `string`):

Ranking hint only. Eventbrite may return events without this keyword.

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

Relevance or date order. Ongoing multi-day events may start in the past.

## `max_items` (type: `integer`):

Maximum unique delivered events across all cursor pages. Keep unchanged when continuing.

## `cursor` (type: `string`):

Opaque next_cursor from the previous response. Repeat the original input. Apify follows automatically.

## Actor input object example

```json
{
  "location": "Amsterdam",
  "online_only": false,
  "category": "music",
  "date_preset": "any",
  "price": "any",
  "sort": "relevance",
  "max_items": 50
}
```

# Actor output Schema

## `events` (type: `string`):

One row per unique event.

## `output` (type: `string`):

Counts, status, warnings and continuation metadata.

## `errors` (type: `string`):

Redacted source errors when present.

## `resolved_place` (type: `string`):

Eventbrite location choice, available for city-name searches.

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

Search filters sent to Eventbrite, without request credentials.

# 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 = {
    "location": "Amsterdam",
    "category": "music"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/eventbrite-events").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 = {
    "location": "Amsterdam",
    "category": "music",
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/eventbrite-events").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "location": "Amsterdam",
  "category": "music"
}' |
apify call s-r/eventbrite-events --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/eventbrite-events"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/pUx5le3EPlbb0EnQf/builds/Dq1KdU4VA8kIq5WE3/openapi.json