# Eventbrite Events Scraper: Any City, Any Day (`tidyharvest/eventbrite-day`) Actor

Every Eventbrite event in a city on any day (or by keyword/category), with price range, venue and coordinates, organizer and category. Built to beat aitorsm/eventbrite: the same 196 events on a full San Francisco day, at $0.80 per 1,000 vs their $20 (Oct 2026).

- **URL**: https://apify.com/tidyharvest/eventbrite-day.md
- **Developed by:** [TidyHarvest](https://apify.com/tidyharvest) (community)
- **Categories:** Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 event scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Eventbrite Events Scraper: Any City, Any Day

List **every Eventbrite event in a city on a given day**, with **price range, venue and coordinates, organizer, category and sold-out status**, in clean structured data. Built for local event calendars, newsletters, ticketing research and lead generation.

Fast and cheap: a full big-city day takes seconds to a couple of minutes and costs under a cent of compute. **No proxy, login or API key.**

### Built to beat aitorsm/eventbrite

Same city, same day (San Francisco, Oct 21 2026), run the same afternoon:

| | This actor | aitorsm/eventbrite (most-used) |
|---|---|---|
| Events on that day | **196** | 196 of the same events (+3 multi-day events that started earlier) |
| Price, any event found | **$0.80 per 1,000 on Free, $0.48 on Gold** | $20 per 1,000 on Free, $5 on Gold |
| What that day cost | **$0.16** | $1.99 (our account's plan) |
| Run time (this one run) | **41 s** | 219 s |
| Price per event in rows | 196 of 196 | 193 of 199 |

**Where they still win:** organizer enrichment (badges, follower and hosting stats, social links) and a whole-country search; for organizer profiles use our [Eventbrite organizers actor](https://apify.com/tidyharvest/eventbrite-organizer-scraper) instead.

### What you can do with it

- **City event calendars and newsletters:** refresh "what's on this weekend" with a daily scheduled run.
- **Event marketers and sponsors:** find events by category, price and organizer in your target cities.
- **Lead generation:** build lists of organizers running events near you.
- **Market research:** compare event supply, free vs paid mix and pricing across cities and dates.
- **Keyword and category search:** "salsa dance in San Francisco next week" or "food & drink in Boston", in the same order Eventbrite's own search shows them.
- **Price checks:** look up any list of event ids for current price range, free and sold-out status.

### Input

```json
{
  "searches": [
    {"hub": "ca--san-francisco", "date": "2026-10-23"},
    {"hub": "ny--new-york", "date": "2026-10-23", "price": "split"}
  ],
  "maxItems": 1000
}
```

`hub` is the city slug in the Eventbrite URL `eventbrite.com/d/<hub>/all-events/`, e.g. `ca--san-francisco`, `ny--new-york`, `il--chicago`, `united-kingdom--london`. Add as many city/day pairs as you like to one run. For a scheduled run, use a relative date: `"date": "tomorrow"`, `"today"`, `"+3"` or `"today+7"` (days from today, UTC); `from`/`to` take them too.

Eventbrite caps a single search at about 950 results. With `price: "auto"` (default), the actor automatically splits big days into free and paid listings so you still get the complete day. Use `"split"` to always do so.

**Keyword or category search** instead of a whole day: give `q` (keyword) or `category`, optionally a date range, and how many result pages (about 20 events each) to read:

```json
{"searches": [
  {"hub": "ca--san-francisco", "q": "salsa dance", "from": "2026-10-20", "to": "2026-10-26", "pages": 2, "label": "dance"},
  {"hub": "ma--boston", "category": "food-and-drink", "pages": 3}
]}
```

Categories: `business`, `food-and-drink`, `health`, `music`, `charity-and-causes`, `community`, `family-and-education`, `film-and-media`, `hobbies`, `performing-and-visual-arts`, `government`, `science-and-tech`, `sports-and-fitness`, `travel-and-outdoor`, `school-activities`, `holiday`, `spirituality`, `fashion`, `home-and-lifestyle`. Results come in Eventbrite's own order (sponsored listings included, flagged `isPromoted`), with venue, times and category. Eventbrite's search results don't show most prices, so price fields are empty there; pass those ids to `eventIds` to fill them.

**Price and time lookups:** `{"eventIds": ["1994021015535", "2001706333528"]}` returns each event's start/end, `priceMin`/`priceMax`, `isFree`, `isSoldOut` and status (up to 2,000 ids per run; can be combined with `searches`). An id that no longer exists or is private returns `found: false` and is not charged.

Optional: `outputMode` (`items` default, or `bundle`) and `proxy` (`none` default, `datacenter`, `residential`; also settable per search). Some non-US cities (Bangkok, Shenzhen, Nairobi, Sydney) answer HTTP 429 to Apify's own IPs: use `"proxy": "residential"` there (billed as normal Apify Proxy traffic, about $0.002 per city-day). A city-day that Eventbrite itself lists as empty succeeds with no events and no event charge. Set `escalateOnRateLimit: true` to have a run that Eventbrite refuses twice in a row switch to a fresh residential IP and retry that search instead of stopping (`maxRotations`, default 2; `residentialMaxRequests`, default 80, about 56 MB). Off by default, because residential traffic is billed to your account.

### Output

One item per event:

```json
{
  "id": "123456789", "name": "Friday Night Salsa", "summary": "...", "url": "https://www.eventbrite.com/e/...",
  "startDate": "2026-10-23T20:00:00 America/Los_Angeles", "endDate": "...", "timezone": "America/Los_Angeles",
  "isOnline": false, "isFree": false, "priceMin": 15, "priceMax": 25, "isSoldOut": false, "category": "Music",
  "organizer": {"name": "...", "url": "..."},
  "venue": {"name": "...", "address1": "...", "city": "San Francisco", "region": "CA", "latitude": 37.77, "longitude": -122.41},
  "hub": "ca--san-francisco", "searchDate": "2026-10-23", "searchTotal": 296
}
```

With `"outputMode": "bundle"` the dataset has one item per search instead: `{"hub", "searchDate", "searchTotal", "count", "empty", "shortfall", "truncated", "events": [ ...the event objects above... ]}`. Same events and same price per event; use it when you read a whole city-day at once.

Keyword and category results carry the same event fields plus `isPromoted`, and `q`, `category`, `from`, `to`, `label` of their search (in bundle mode: one item per search with those fields, `searchTotal`, `count`, `pages` and `events`).

`searchTotal` is Eventbrite's own count for that search, so you can see how complete the result is. Only events starting on the searched day are returned (multi-day events appear on their start day).

### Pricing

**$0.80 per 1,000 events on the Free plan, $0.72 Bronze, $0.60 Silver, $0.48 Gold and up** (a found event-id lookup counts as one event). Failed or empty runs are not billed for events.

### Notes

- Uses the same public search JSON Eventbrite's own listing pages use, politely (one request every 2 seconds, backs off on a rate limit).
- The run fails loudly rather than returning a silently incomplete day: if Eventbrite rate-limits it or returns far fewer events than it reports, the run is marked failed so your automation notices.
- Public events only.

# Actor input Schema

## `searches` (type: `array`):

One entry per search. **Whole day:** `{"hub": "ny--new-york", "date": "2026-10-23"}` lists every event that day. Dates can also be relative, for scheduled runs: `today`, `tomorrow`, `+3` or `today+3` (days from today, UTC). Hub = the city slug from the Eventbrite URL `eventbrite.com/d/<hub>/all-events/` (`ca--san-francisco`, `ny--new-york`, `il--chicago`, `united-kingdom--london`). `price`: `auto` (default; splits free/paid only when a day exceeds the site's ~950-result cap), `split`, `free` or `paid`. **Keyword or category:** `{"hub": "ca--san-francisco", "q": "salsa dance", "from": "2026-10-20", "to": "2026-10-26", "pages": 2}` or `{"hub": "ma--boston", "category": "food-and-drink", "pages": 3}` returns the events in the same order Eventbrite's own search shows them, about 20 per page (`pages`, default 1, up to 20). `from`/`to` are optional (default: all upcoming). Categories: business, food-and-drink, health, music, charity-and-causes, community, family-and-education, film-and-media, hobbies, performing-and-visual-arts, government, science-and-tech, sports-and-fitness, travel-and-outdoor, school-activities, holiday, spirituality, fashion, home-and-lifestyle. Keyword and category results carry venue, times and category; their price fields are empty unless Eventbrite shows the price in search (add their ids to `eventIds` for prices). An optional `label` is copied to every result of that search. Many searches can share one run.

## `eventIds` (type: `array`):

Eventbrite event ids (the number at the end of an event URL) to look up one by one: start and end time, price range (`priceMin`/`priceMax`), free and sold-out flags. Up to 2,000 per run. An id that no longer exists or is private comes back with `found: false` and is not charged. Can be combined with `searches` or used alone.

## `hub` (type: `string`):

City slug from the Eventbrite URL, e.g. `ny--new-york`. Used when `Searches` is empty.

## `date` (type: `string`):

Day to list, `YYYY-MM-DD`, or relative: `today`, `tomorrow`, `+3`. Used when `Searches` is empty.

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

`auto`, `split`, `free` or `paid`. See Searches.

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

Cap per city and day (also caps your cost).

## `requestDelaySeconds` (type: `integer`):

Politeness delay. Keep at 2 or more to avoid rate limits.

## `outputMode` (type: `string`):

`items` (default): one dataset row per event. `bundle`: one row per city and day with every event in an `events` array plus `searchTotal`, `count`, `empty`. Same events and same price per event; fewer dataset writes, so cheaper to run for pipelines that read a whole day at once.

## `proxy` (type: `string`):

`none` (default) uses Apify's own IPs, which work for most cities. Some non-US hubs (Moscow, Bangkok, Shenzhen, Nairobi...) answer HTTP 429 to those IPs; try `datacenter`, then `residential`. Proxy traffic is billed to your account as normal Apify Proxy usage. A search entry can carry its own `proxy`.

## `escalateOnRateLimit` (type: `boolean`):

When Eventbrite answers HTTP 429 twice in a row, switch to a fresh Apify residential IP and retry that search instead of stopping the run. Residential traffic is billed to your account (a listing page is about 0.7 MB). Off by default.

## `maxRotations` (type: `integer`):

Only used with 'Switch IP on a repeated 429'. After this many switches a further 429 stops the run.

## `residentialMaxRequests` (type: `integer`):

Only used with 'Switch IP on a repeated 429'. The most requests a run sends through residential proxy; past it a 429 stops the run. A listing page is about 0.7 MB, so 80 requests is about 56 MB.

## Actor input object example

```json
{
  "searches": [
    {
      "hub": "ca--san-francisco",
      "date": "tomorrow",
      "price": "auto"
    }
  ],
  "hub": "ca--san-francisco",
  "price": "auto",
  "maxItems": 1000,
  "requestDelaySeconds": 2,
  "outputMode": "items",
  "proxy": "none",
  "escalateOnRateLimit": false,
  "maxRotations": 2,
  "residentialMaxRequests": 80
}
```

# Actor output Schema

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

Eventbrite events, one item per event.

# 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 = {
    "searches": [
        {
            "hub": "ca--san-francisco",
            "date": "tomorrow",
            "price": "auto"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tidyharvest/eventbrite-day").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 = { "searches": [{
            "hub": "ca--san-francisco",
            "date": "tomorrow",
            "price": "auto",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("tidyharvest/eventbrite-day").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 '{
  "searches": [
    {
      "hub": "ca--san-francisco",
      "date": "tomorrow",
      "price": "auto"
    }
  ]
}' |
apify call tidyharvest/eventbrite-day --silent --output-dataset

```

## MCP server setup

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

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/bI1TEMvcarhVvj0Jn/builds/rcMZAi1oycQdwgLGO/openapi.json