# Eventbrite Events Scraper — By City & Topic, Prices (`northbell/eventbrite-events-scraper`) Actor

Scrape Eventbrite events by city and topic (tech, AI, music, startup — any search word) or online: date and time zone, venue, address, coordinates, ticket prices (free, from, up to), sold out, organizer, category, optional full description. Only new events since your last run. No login.

- **URL**: https://apify.com/northbell/eventbrite-events-scraper.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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.
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 — By City & Topic, Prices

Give it a list of searches — a city and a topic word (`tech`, `ai`, `music`, `startup`, any word you would type into Eventbrite), or `online` — and get one clean row per **Eventbrite** event: **name, start and end time with time zone, venue, address, coordinates, ticket prices (cheapest, most expensive, free or not), sold-out status, organizer and category**. **$1.50 per 1,000 events**, no login, no API key.

Run it again — or put it on a daily schedule — and every row also tells you whether the event is **new since the last run** (`isNewSinceLastRun`). Switch on *Only new events* and each run returns just what Eventbrite added since the one before.

Fixed 22 Oct 2026: events the previous run had simply not reached (it stopped at *max events*) counted as new, so with *Only new events* a second run could return the next page of older events as new and charge for them. New now means it appeared within the part of the list the previous run read, or was listed on Eventbrite after that run. A run with *Only new events* no longer widens that part of the list, so with nothing new it stops after a page or two instead of reading up to 49 pages.

### What you get

| Field | What it is |
|---|---|
| `name`, `url`, `eventId`, `summary`, `language`, `imageUrl`, `listedAt` | the event; `summary` is the short blurb, `listedAt` is when the organizer published it |
| `startAt`, `endAt`, `startLocal`, `endLocal`, `timezone` | start and end in UTC and as local wall time (`2026-10-12T17:00`) in the event's time zone; `endAt` is empty when the organizer hides the end |
| `locationType` | `in-person` or `online` |
| `venue`, `address`, `city`, `region`, `postalCode`, `country`, `countryCode`, `latitude`, `longitude` | where it happens (empty for online events) |
| `isFree`, `price`, `maxPrice`, `currency`, `hasFreeTicket` | tickets: `price` is the cheapest ticket, `maxPrice` the most expensive; `isFree` is `true` only when every ticket is free; `hasFreeTicket` is `true` when a free ticket sits next to paid ones |
| `soldOut`, `ticketsAvailable`, `salesStatus`, `salesEndAt` | whether tickets can still be bought (`on_sale`, `sales_ended`, …) and when sales end |
| `organizerName`, `organizerUrl`, `organizerId`, `organizerFollowers` | the organizer's name, Eventbrite page, id and follower count — group rows by `organizerId` to see who runs the most events |
| `category`, `subcategory`, `format`, `tags` | Eventbrite's category and format ("Science & Technology", "Seminar or Talk") and the organizer's tags |
| `seriesId` | set when the event is one date of a recurring series |
| `description`, `durationMinutes`, `ageRestriction`, `organizerEventsHosted`, `organizerTotalAttendees`, `organizerVerified` | with *Include full details* |
| `search`, `isNewSinceLastRun`, `observedAt` | which search it came from, whether it is new since your last run (`null` on the first run), and when it was read |

Organizers' social handles, websites and profile texts are **not** collected, and email addresses and phone numbers are removed from every text field.

### Use it for

- **Event discovery** — every tech, AI or startup event in your city for the next two weeks, with prices, in one sheet
- **Sponsorship and sales** — which organizers run the most events, how big their audience is (`organizerFollowers`, with full details also events hosted and total attendees), and where
- **Market research** — events per category, paid vs free, and ticket price ranges in any city
- **Alerts** — schedule it daily with *Only new events* and send new listings to Slack or email

### Input

```json
{
  "searches": [
    { "location": "San Francisco, CA", "query": "tech" },
    "ai | London, United Kingdom",
    "online"
  ],
  "startsWithinDays": 14,
  "maxEventsPerSearch": 100
}
```

A search is `{"location": "San Francisco, CA", "query": "tech"}` or the short form `"tech | San Francisco, CA"`. Write locations as `City, ST` in the US, `City, Country` elsewhere (`London, United Kingdom`, `Tokyo, Japan`), or `online`. Leave the query out for every event in a place. You can also paste an `eventbrite.com/d/…` search link.

Measured on October 8, 2026: San Francisco tech and Austin AI, 60 events each (120 events, 8 pages) in 33 seconds; 10 in-person events with full details in 19 seconds. Data comes from Eventbrite's public search pages and event listings — no login.

### Pricing

**$1.50 per 1,000 events**, plus $0.01 per run. Error rows and events left out by your filters (free only, start window, only new) are free. *Include full details* costs the same. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- Public data only: what anyone sees on Eventbrite without signing in.
- Eventbrite shows about 19 events per page and at most 49 pages per search (roughly 900 events), ordered by relevance, not by date. Use several search words to cover more, or *Starting within the next N days* to narrow a busy city.
- Eventbrite's own search is loose: any search word returns a full list, and the matches get weaker further down the pages. For a narrow topic keep *Max events per search* modest, or check `category` and `name` in your results.
- *Starting within the next N days* counts from the moment the run starts; a multi-day event that is already under way is kept.
- Sponsored placements that Eventbrite inserts at the top of a search (often events from another country) are skipped.
- *Free events only* keeps events where every ticket is free; events that also sell paid tickets are skipped (`hasFreeTicket` shows them in a normal run). With no search word it uses Eventbrite's own list of free events. With a search word it has to read the normal pages and drop the paid ones, so a topic with few free events can mean many pages (about 1.5 seconds each) before your limit is reached.
- Prices are the amounts in Eventbrite's own listing data, in the event's currency; the total at checkout can differ (fees, taxes). `price` and `maxPrice` are empty when that data has no ticket price for the event (rare; seen on a listing that was on sale but had none). `isFree` is then empty too, because Eventbrite does not say the event is free. `organizer` is empty on events where the organizer page has no name.
- `organizerName` is the name the organizer shows on Eventbrite (e-mail addresses and phone numbers in it are removed); `organizerId` identifies the same organizer across rows and runs.
- An event that matches more than one of your searches is returned once, under the first search that found it, and charged once.
- Some fields depend on what the organizer filled in, so they are empty on part of the rows: `endAt` and `endLocal` (end time hidden), `seriesId` (only dates of a recurring series), `category`, `subcategory`, `format`, `tags`, `summary`, `imageUrl`, `salesEndAt`, `region`, `postalCode`, and with full details `description` and `ageRestriction` (`18+`, `All ages`, …).
- `ticketsAvailable` and `organizerFollowers` come from Eventbrite's listing data. If that is unavailable for a run, the Actor reads each event page instead (slower) and these two stay empty.
- Eventbrite limits how fast it can be read. The Actor spaces its requests about 1.5 seconds apart, waits and retries when it is told to slow down, and keeps the events already read if a later page fails (you get one free error row for that search).
- Online events have no venue, address or country. Places Eventbrite shows in the local language (Tokyo, for example) keep their local spelling in `venue`, `address` and `city`.

To find events on other platforms, see [Luma Events Scraper](https://apify.com/northbell/luma-events-scraper) and [Meetup Events Scraper](https://apify.com/northbell/meetup-events-scraper).

### For AI agents

`{"searches": ["tech | London, United Kingdom"], "startsWithinDays": 7, "maxEventsPerSearch": 20}` returns next week's London tech events with prices and organizer ids. Rows have `type`: `event` or `error`.

# Actor input Schema

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

What to look for and where. Each search is {"location": "San Francisco, CA", "query": "tech"} or the short form "tech | San Francisco, CA". Locations: "City, ST" for the US, "City, Country" elsewhere ("London, United Kingdom"), or "online". Leave the query out for all events in a place. You can also paste an eventbrite.com/d/… search link.

## `startsWithinDays` (type: `integer`):

Keep only events that start within this many days from now (a multi-day event that is already under way also counts). Leave empty for every upcoming event.

## `freeOnly` (type: `boolean`):

Keep only events where every ticket is free. Events that also sell paid tickets are skipped (they are marked hasFreeTicket in the normal output). Skipped events are not charged.

## `maxEventsPerSearch` (type: `integer`):

How many events to return for each search. Eventbrite shows about 19 per page and up to 49 pages per search, ordered by relevance.

## `includeDetails` (type: `boolean`):

Adds the full description (contact details removed), duration, age limit and how many events and attendees the organizer has had. One extra page per event, so the run is slower. Same price.

## `onlyNew` (type: `boolean`):

From the second run on, return only events this Actor has not returned before for the same place and search word.

## Actor input object example

```json
{
  "searches": [
    {
      "location": "San Francisco, CA",
      "query": "tech"
    }
  ],
  "freeOnly": false,
  "maxEventsPerSearch": 100,
  "includeDetails": false,
  "onlyNew": false
}
```

# Actor output Schema

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

Date, venue, ticket prices, sold-out status, organizer and category.

# 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": [
        {
            "location": "San Francisco, CA",
            "query": "tech"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/eventbrite-events-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searches": [{
            "location": "San Francisco, CA",
            "query": "tech",
        }] }

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

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

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

```

## CLI example

```bash
echo '{
  "searches": [
    {
      "location": "San Francisco, CA",
      "query": "tech"
    }
  ]
}' |
apify call northbell/eventbrite-events-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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