Eventbrite Scraper — Events, Organizers & Ticket Prices

Scrape Eventbrite and get one row per event, carrying name, summary, start_date, start_time, end_date, end_time, timezone, venue_name, venue_address, venue_city, venue_region, venue_postal_code, venue_latitude, venue_longitude, organizer_name, organizer_url, organizer_id, price_min, price_max, price_currency, is_free, ticket_availability, categories, subcategories, formats, keywords, image and tickets_url.

Search by city, keyword, one of Eventbrite's 21 categories, a date window, or free-events-only — or just paste an eventbrite.com search or event URL and skip the filters entirely. No login. No API key. No CAPTCHA solving. Both surfaces this Actor reads are JSON that Eventbrite embeds in its own server-rendered pages.

Measured scope, 2026-08-13: Eventbrite reports page_count = 49 on an Austin search — identically on all-events, music and business — but it still serves page 50, and page 51 comes back empty with object_count collapsing to exactly 1000. So one search tops out at ~1,000 events — a full 50-page Austin walk on 2026-08-13 returned 981 unique events from 1,000 cards in 147 seconds — and this Actor walks that 50th page rather than trusting the reported 49. That is a source cap, not an Actor limit, and it is why the category / keyword / date filters exist: they are how you get past 1,000 in a city. Measured live on Austin (all-events + music), London and New York — not quoted from a marketing page.

The wedge, with its number: organizer_name and organizer_url are filled on 92.5% and 95.0% of rows, and price_min/price_max on 95.0% — measured on 120 contiguous Austin events on 2026-08-12. Neither the organizer's name nor the ticket price exists on an Eventbrite listing page; both come from a second request this Actor makes for you.

Quick start — this is the input it ships with

{
  "location": "Austin, TX",
  "maxResults": 20
}

Click Try for free and hit Start. That is the literal prefilled input; it needs zero edits. Measured on 2026-08-12 it returned 20 rows in 20 seconds (1 listing fetch + 20 detail fetches).

1. Create a free Apify account.
2. Open the Actor and press Start — or type a different city into City first.
3. Watch the log: it prints rows per page, duplicates dropped, and this run's own measured field fill.
4. Open the Dataset tab and switch between the Events, Organizer leads and Venues & geo views.
5. Export CSV / JSON / Excel, or pull it from the API.

Signup to downloaded dataset is about 3 minutes at the default 20-row cap.

Copy this to your AI assistant

scrapersdelight/eventbrite-scraper on Apify.
Call: ApifyClient("TOKEN").actor("scrapersdelight/eventbrite-scraper").call(run_input={...}),
then client.dataset(run["defaultDatasetId"]).list_items().items for results.
Key inputs: startUrls (array of {url}, eventbrite /d/ /b/ /e/ pages; wins over all filters),
location (string, "Austin, TX" or slug "tx--austin"/"united-kingdom--london"; prefilled in the UI as
"Austin, TX" but NOT defaulted in code — an API call must send location, startUrls or onlineOnly),
locations (array of strings), keyword (string -> ?q=), categories (array of 21 enum slugs),
freeOnly (bool), onlineOnly (bool), startDate/endDate ("YYYY-MM-DD"),
maxResults (int, default 20, = cost cap), maxPages (int, default 3, max 50),
fetchDetails (bool, default true), concurrency (int, default 6), proxyConfiguration.
Billing: $0.0045 per event returned, event id "event-scraped", no actor-start charge.
Full actor spec: GET https://api.apify.com/v2/acts/scrapersdelight~eventbrite-scraper (Bearer TOKEN).
Get token: https://console.apify.com/account/integrations

Who buys this, and the field they monetize

Who	What they do with it
Event-sponsorship sales	organizer_name + organizer_url + organizer_id — the person who signs the sponsorship cheque. Listing pages give you an organizer id and nothing else; this is the name.
AV, staging, catering & production vendors	venue_name + venue_address + start_date — who needs gear, where, on which date, 4–12 weeks out.
Ticketing / event-tech SaaS	price_min, price_max, is_free — organizers already selling paid tickets are the ICP; 87.5% of the 120-row Austin sample were paid.
Venue & hospitality sales teams	venue_name frequency across a run tells you which rooms are actually booked and which organizers repeat.
DevRel and community teams	categories: ["Science & Technology"] / ["Business & Professional"] plus organizer_url — the list of local meetups to sponsor or speak at.
City guides, local media, event aggregators	image, tickets_url, summary, venue_latitude/venue_longitude — everything a listings page or a map needs, refreshed on an Apify Schedule.

Read this before you buy rows

1. A single search caps at ~1,000 events. 50 pages × 20 events per page. Eventbrite reports page_count = 49, but page 50 serves 20 more and page 51 is empty — measured on Austin, London and New York. If you need a whole city, run it once per category (21 of them), or slice by date window, or by keyword. maxPages above 50 just stops early.
2. is_free and price_min: 0 are not the same thing. is_free: true means every ticket tier is $0. price_min: 0 means there is a free tier — in the 120-row sample, 22 rows had price_min: 0 but only 9 were is_free: true. The other 13 have a free tier plus paid tiers.
3. Turning fetchDetails off costs you the organizer and the price, and nothing else. It is roughly 20× fewer requests, and the price per event is identical either way — you are billed per row returned, not per fetch.
4. Online events have no address. With onlineOnly on, venue_city, venue_address, venue_latitude and venue_longitude come back null (measured 2026-08-13: 20 of 20). That is Eventbrite, not a bug.
5. keyword is Eventbrite's own fuzzy search, not an exact match, and you pay for what it returns. Measured 2026-08-13: the nonsense query underwater basket weaving qwerty still came back with a full page of 20 Austin events — a basket-weaving class, a crochet-basket class, then loosely related ones. Check the first page at a low maxResults before you raise the cap.
6. Eventbrite's own data has typos in it. One of the 120 Austin rows carries venue_city: "Austi". We pass the source through rather than silently "correcting" it.

What you get — one row per event

Group	Fields
Identity	id (numeric Eventbrite event id, stable — the dedupe key), name, url, summary, image, tickets_url
Schedule	start_date, start_time, end_date, end_time, timezone (local), plus start_datetime / end_datetime (ISO-8601 straight from the detail page — usually 2026-08-23T16:00:00-05:00, but Eventbrite publishes a bare YYYY-MM-DD for some events; see the note below)
Venue	venue_name, venue_address, venue_city, venue_region, venue_postal_code, venue_country, venue_latitude, venue_longitude, is_online_event
Organizer	organizer_name, organizer_url, organizer_id
Money	price_min, price_max, price_currency, is_free, ticket_availability (InStock / SoldOut)
Taxonomy	categories, subcategories, formats (Eventbrite's own tags), keywords (the organizer's own tags)
Provenance	source (always "Eventbrite"), scraped_at (ISO-8601 UTC)

Prices are numbers in price_currency units. Dates in start_date/end_date are local YYYY-MM-DD. start_datetime/end_datetime are passed through exactly as Eventbrite's JSON-LD publishes them: normally full ISO-8601 with the event's offset, but on a minority of events Eventbrite emits a bare YYYY-MM-DD with no time — measured 2026-08-13, 9 of 39 non-null end_datetime values across five runs, versus 1 of 39 for start_datetime. Parse defensively, or use end_date + end_time, which are always split fields. Absent values are null, never dropped, so your CSV columns stay stable run to run.

Field fill — measured on 120 contiguous Austin events, 2026-08-12

Austin, TX · all categories · pages 1–6 walked contiguously · fetchDetails: true · concurrency 6 · 120 rows in 81 seconds.

Field	Fill
id, name, url, start_date, start_time, end_date, end_time, timezone, is_online_event	100.0%
venue_name, venue_address, venue_city, venue_region, venue_postal_code, venue_country	100.0%
venue_latitude, venue_longitude	100.0%
organizer_id, image, tickets_url	100.0%
summary	99.2%
categories, formats	96.7%
organizer_url, price_min, price_max, price_currency, is_free, ticket_availability, start_datetime, end_datetime	95.0%
organizer_name	92.5%
subcategories	91.7%
keywords (organizer's own tags)	85.8%

The number that could mislead you: organizer_name is 92.5%, not 100%. 6 of the 120 detail requests failed after three attempts (that is the 95.0% ceiling every detail-derived field shares), and on 3 further rows Eventbrite itself published "name": null in its JSON-LD while still giving the organizer URL. So: 5% is transport, 2.5% is Eventbrite. organizer_id is 100% either way, and organizer_url at 95.0% is the handle to enrich from.

With fetchDetails: false, everything detail-derived — organizer_name, organizer_url, price_min, price_max, price_currency, is_free, ticket_availability, start_datetime, end_datetime — is null by construction, and every other field above is unchanged.

Every run prints its own measured fill in the log.

How to run it

Search a city

{ "location": "Austin, TX", "maxResults": 60, "maxPages": 3 }

location takes "Austin, TX" or an Eventbrite place slug. Slugs are not US-only — verified live, united-kingdom--london returns 20 rows/page exactly like a US city. Use locations for several cities.

Filter it

{
  "location": "Austin, TX",
  "keyword": "yoga",
  "categories": ["health"],
  "freeOnly": true,
  "startDate": "2026-08-20",
  "endDate": "2026-09-20",
  "maxResults": 10
}

Measured 2026-08-12: that exact input returned 10 rows, 10 of 10 is_free: true, all tagged Health & Wellness, every start_date inside the window. Filters run inside Eventbrite's search, so a filtered run costs fewer fetches, not more.

Paste URLs instead

{
  "startUrls": [
    { "url": "https://www.eventbrite.com/d/ny--new-york/all-events/" },
    { "url": "https://www.eventbrite.com/b/tx--austin/music/" },
    { "url": "https://www.eventbrite.com/e/from-day-one-austin-2026-tickets-1435465258229" }
  ],
  "maxResults": 45
}

Three shapes are supported, all three verified live in one run on 2026-08-12:

• https://www.eventbrite.com/d/<place>/<category>/?… — a search page. Any query string you copied is preserved and paged through, up to maxPages.
• https://www.eventbrite.com/b/<place>/<category>/ — a browse page. Eventbrite's /b/ pages carry no search data, so the Actor rewrites them to the /d/ path that does, rather than returning nothing.
• https://www.eventbrite.com/e/<slug>-tickets-<id> — one event, one row, built from that page alone.

Organizer /o/ pages are rejected with an error naming the supported shapes, instead of silently producing nothing. When startUrls is set, the city / keyword / category / date / free filters are ignored and the run logs a warning saying so.

Online events only

{ "onlineOnly": true, "categories": ["business"], "maxResults": 50 }

Measured 2026-08-13: 20 of 20 rows came back is_online_event: true, with venue_city, venue_latitude and venue_longitude all null.

Cheap mode

{ "location": "Austin, TX", "maxResults": 200, "maxPages": 10, "fetchDetails": false }

~20× fewer requests. You keep name, schedule, full venue address, lat/lon, categories, image and tickets URL. You give up organizer name/URL and ticket price. Same price per event.

Sample row — a real record from the 2026-08-12 Austin run

{
  "id": "1986659414789",
  "name": "No Man's Land Film Festival Presents: Seoul to Sol",
  "url": "https://www.eventbrite.com/e/no-mans-land-film-festival-presents-seoul-to-sol-tickets-1986659414789",
  "summary": "Join us for the premiere of documentary Seoul to Sol, followed by a conversation on rock climbing, community, and belonging in the outdoors.",

  "start_date": "2026-08-23",
  "start_time": "16:00",
  "end_date": "2026-08-23",
  "end_time": "19:30",
  "timezone": "America/Chicago",
  "start_datetime": "2026-08-23T16:00:00-05:00",
  "end_datetime": "2026-08-23T19:30:00-05:00",

  "is_online_event": false,
  "venue_name": "AFS Cinema",
  "venue_address": "6259 Middle Fiskville Road, Austin, TX 78752",
  "venue_city": "Austin",
  "venue_region": "TX",
  "venue_postal_code": "78752",
  "venue_country": "US",
  "venue_latitude": 30.3243646,
  "venue_longitude": -97.7086944,

  "organizer_id": "121212027087",
  "organizer_name": "Seoul to Sol Film",
  "organizer_url": "https://www.eventbrite.com/o/seoul-to-sol-film-121212027087",

  "price_min": 10.38,
  "price_max": 10.38,
  "price_currency": "USD",
  "is_free": false,
  "ticket_availability": "InStock",

  "categories": ["Film, Media & Entertainment"],
  "subcategories": ["Film"],
  "formats": ["Screening"],
  "keywords": ["Movie", "Sports", "Filmfestival", "Filmscreening", "Rockclimbing",
               "Koreanculture", "Nomansland", "indiefilmscreen", "asianfilmshowcase", "womanclimber"],

  "image": "https://img.evbuc.com/…",
  "tickets_url": "https://www.eventbrite.com/checkout-external?eid=1986659414789",
  "source": "Eventbrite",
  "scraped_at": "2026-08-13T01:50:23.501Z"
}

Three things people misread:

• price_min == price_max means one ticket tier, not a missing range. In the 120-row sample the median price_min was $30.87 and the highest $2,787.22.
• keywords are the organizer's free-text tags; categories/subcategories/formats are Eventbrite's controlled taxonomy. Only the latter are safe to group by.
• organizer_id is present even when organizer_name is not — it comes from the listing page, the name from the detail page.

Input

Field	Type	Default	What it does
startUrls	array (URLs)	—	Paste /d/, /b/ or /e/ eventbrite.com URLs. Wins over every filter below.
location	string	"Austin, TX" (prefilled)	City, or an Eventbrite place slug (tx--austin, united-kingdom--london).
locations	array	—	Several cities in one run; replaces location. Each city costs its own listing pages.
onlineOnly	boolean	false	Search Eventbrite's online place instead of a city. No venue/geo on those rows.
keyword	string	—	Free text, appended as ?q=.
categories	multi-select	(none = all)	Eventbrite's 21 categories. Each one you tick is a separate search — 3 categories × 3 pages = 9 listing fetches.
freeOnly	boolean	false	Searches Eventbrite's free-events path. See the honest limit below about "paid only".
startDate	date	—	YYYY-MM-DD; events starting on or after. A malformed date stops the run.
endDate	date	—	YYYY-MM-DD; events starting on or before.
maxResults	integer	20 (prefilled)	Your hard cost cap. Duplicates are dropped before billing and never count against it.
maxPages	integer	3 (max 50)	Listing pages per (city × category), ~20 events each.
fetchDetails	boolean	true	Second request per event for organizer + price. Off = ~20× fewer requests, same price per row.
concurrency	integer	6	Parallel detail fetches. 6 is what the published throughput was measured at.
proxyConfiguration	proxy	Apify RESIDENTIAL, country US	Overridable. The default is measured, not cautious — see the ladder below.

Category slugs

music · business · food-and-drink · community · arts · film-and-media · sports-and-fitness · health · science-and-tech · travel-and-outdoor · charity-and-causes · spirituality · family-and-education · holiday · government · fashion · home-and-lifestyle · auto-boat-and-air · hobbies · school-activities · other

All 21 were walked live on 2026-08-12 and each returned 19–20 rows. Note that Eventbrite's display names differ from its slugs: arts is "Performing & Visual Arts", health is "Health & Wellness", spirituality is "Religion & Spirituality". A slug that is not on this list stops the run with an error that lists the valid ones, rather than quietly returning nothing.

Pricing

$0.0045 per event returned — $4.50 per 1,000. Charged on the event-scraped event. There is no charge to start a run, and no monthly platform fee from this Actor.

You are charged for rows delivered. You are never charged for a listing page, never for a detail fetch that failed, never for a retry, never for our proxy budget, and never twice for the same event — duplicates are dropped on the Eventbrite event id before anything is billed. Rows are charged as they are pushed, so if you hit a budget cap you get whole rows and stop, not a half-billed dataset.

Run	Events	Cost
The prefilled default	20	$0.09
One city, 3 pages	60	$0.27
One city, all events, to the source cap (measured)	981	$4.41
Three categories, 3 pages each (measured)	167	$0.75
Ten cities × 1,000	10,000	$45.00

maxResults is the dial: it is a hard cap on rows and therefore a hard cap on spend.

Honest limits

• ~1,000 events per search, full stop. Eventbrite reports page_count = 49 at 20 results per page, measured identically on Austin all-events, music and business — but the reported count is one short: page 50 serves 20 more events, and page 51 returns nothing at all with object_count reading exactly 1000 (verified 2026-08-13 on Austin, London and New York). This Actor walks all 50. There is no page 51, and no parameter that produces one. Slice by category, keyword or date window instead.
• There is no "paid events only" filter, deliberately. Eventbrite's /paid--events/ path returned the same unfiltered result set as the open search (2 of 8 sampled rows were free), and the ?price= query parameter is a no-op — on 2026-08-12 ?price=free and ?price=paid returned the same 8 events in the same order with the same prices. freeOnly uses the /free--events/ path, which does work (8 of 8 sampled rows at $0). For paid-only, filter is_free after the run.
• 5.0% of detail requests fail and stay failed. 6 of 120, after three attempts each, on residential proxies. Those rows still ship, with the listing fields at 100% and the detail fields null.
• No email addresses, and none can be produced. Eventbrite publishes no organizer email anywhere on these surfaces. organizer_url (95.0%) is the handle — the organizer's public Eventbrite page. Anyone selling you "Eventbrite organizer emails" generated them somewhere else.
• No attendees, no ticket-buyer data, no private events. Attendee lists live behind the organizer's own login. This Actor does not log in, so it cannot and does not touch them.
• Past events are not covered. Eventbrite's search surface serves upcoming events; startDate in the past does not resurrect them.
• Online rows have no geography, and keywords (85.8%) are absent on any event whose organizer never tagged it.
• No CAPTCHA solving, no challenge-breaking. When a request is challenged, the Actor retries twice and then reports the failure. That is the whole mitigation.

How it works, and the measured transport ladder

Two surfaces, both plain JSON that Eventbrite server-renders into its own pages — no browser, no private API, no key:

1. Listing page /d/<place>/<category>/?page=N embeds window.__SERVER_DATA__ → search_data.events.results[] (~20 events) plus pagination.page_count. A brace-balanced extractor walks the blob rather than regexing it, so a } inside a string value cannot truncate it.
2. Detail page /e/<slug>-tickets-<id> carries a schema.org application/ld+json Event block with the organizer name/URL, the offer price range and ISO datetimes.

A note on the category path: /d/<place>/music--events/ 301s to /b/<place>/music/, which carries no search data at all and yields 0 rows. The live search path is the bare slug, /d/<place>/music/. That is why this Actor builds — and rewrites pasted /b/ URLs to — the /d/ form.

Transport ladder — 20 distinct Austin listing pages, one attempt each, no retries, 2026-08-12:

Rung	Result
Direct, no proxy, home broadband	20/20 — but not a shippable rung; no Apify container has a residential home IP
Apify proxy, auto/datacenter, rotating IP	4/20 usable — 15 × HTTP 405 (AWS-WAF), 1 transport error
Apify RESIDENTIAL (US), fresh session per request	18/20 usable — 1 × 405, 1 timeout

An earlier measurement on 2026-07-30 put datacenter at ~87% challenged and residential at 16/16 usable; today's numbers are in the same place. Both were measured through Apify, which is the only measurement that means anything here.

Sustained load, same day: the 120-row Austin run made 126 content requests through residential proxies at concurrency 6 and got 120 usable = 95.2%, with retries. All 6 listing fetches succeeded; 6 of 120 detail fetches did not.

Uniqueness and duplicates

• Contiguous walk, Austin pages 1–6, 2026-08-12: 120 cards → 120 unique ids, 0 duplicates. Sparse-offset sampling would prove nothing here, so the pages were walked back to back.
• Across categories, duplicates are real: 180 cards → ~167 unique, 12–13 dropped = 6.7–7.2%. Measured twice on Austin music + arts + community, 3 pages each: 12 of 180 on 2026-08-12 and 13 of 180 on 2026-08-13. The mechanism is simple — an event tagged in two Eventbrite categories appears in both searches.
• Dedupe happens on the numeric id before anything is fetched or billed, so the dataset never holds the same event twice and your bill never counts it twice. The run log prints the number dropped.
• Across runs, dedupe on id yourself. Two daily runs of the same city will overlap heavily; a narrower date window or a startDate of tomorrow is the cheap way to pull only what is new.

When a run fails

• Zero rows throws. The error names the scope and the HTTP counts (

  0 rows from N/M successful listing fetches
  ) instead of shipping a green-but-empty dataset. There is no legitimate zero here.
• A bad category slug throws, listing all 21 valid slugs.
• A malformed startDate/endDate throws before any request is made.
• An unsupported Start URL throws, naming the three shapes that are supported.
• A failed detail fetch does not fail the run — the row ships with the listing fields and null organizer/price, and the run's log prints the parse rate so you can see it.

Related Actors from the same publisher

Actor	What it is	Why you would use it instead
The Bash Vendor Scraper	DJs, bands, photographers and other event vendors	You want the people the event hires, not the event
Roaming Hunger Food Truck Scraper	Food trucks with cuisines and contacts	You are catering the event rather than selling to it

Eventbrite is where you go for the organizer and the ticket price; those two are where you go for the suppliers.

FAQ

Does this need an Eventbrite account, login or API key? No. Both surfaces are public server-rendered pages with the data embedded as JSON. The Actor never authenticates.

Why not just use the official Eventbrite API? Eventbrite's public API no longer exposes event search; you can only read events you own. Public discovery by city and category is exactly the gap this fills.

My run returned 0 results — what happened? It would have thrown rather than returned 0, and the error names the scope. The usual cause is a city slug Eventbrite does not recognise. Use "Austin, TX" form, or copy the slug straight out of an eventbrite.com URL (/d/united-kingdom--london/… → united-kingdom--london).

Can I get the whole city in one run? Not in one search — the source caps at ~1,000 events. Tick several categories, or run date windows, to go deeper. Ticking 21 categories × 50 pages is the maximum extraction a single city allows.

Can I get organizer email addresses? No, and nothing on these pages can produce one. organizer_url (95.0% fill) is the public organizer page; enrich from there with your own tooling.

Can I scrape attendees, ticket buyers or sales numbers? No. That is behind the organizer's login and this Actor does not log in.

Why are some organizer_name and price_min values null? 95.0% is the detail-fetch ceiling (6 of 120 requests failed after three attempts), and on ~2.5% of rows Eventbrite itself publishes a null organizer name. Every listing-derived field is unaffected at 100%.

Do I get charged for rows I filter out afterwards? You are charged per row returned by the Actor. Anything you filter in your own spreadsheet afterwards was already billed, so push filters into the input — categories, keyword, freeOnly and the date window all run inside Eventbrite's search.

Two runs of the same city — will I get duplicates? Within a run, no (0 of 120 on a contiguous walk; 12–13 of 180 dropped across categories). Across runs, dedupe on id, or move startDate forward so you only pull what is new.

Does it need a proxy? Yes, and the default is right: Apify datacenter IPs were usable on 4 of 20 requests, residential on 18 of 20, measured 2026-08-12. You can override it in the input if your own testing disagrees.

Can I run it on a schedule? Yes — add an Apify Schedule. A daily 20-row pull costs $0.09. Pair it with startDate = tomorrow to keep each run mostly new events.

Does it work outside the US? Yes. united-kingdom--london was verified returning a full page of rows; any Eventbrite place slug works. Prices come back in the event's own price_currency.

Legal & fair use

This Actor reads publicly available Eventbrite pages — the same HTML any visitor's browser receives. It does not log in, does not solve CAPTCHAs, does not circumvent any anti-bot challenge (a challenged request is simply retried twice and then reported as failed), and collects nothing behind authentication.

Some fields — organizer_name, organizer_url — are personal data where the organizer is an individual. You are responsible for complying with Eventbrite's Terms of Service and with how you use the data, including GDPR, CCPA, CAN-SPAM and PECR for any outreach.

Eventbrite® is a trademark of its owner. This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Eventbrite.

Feedback

Found a missing field or want a new filter? Open an issue on the Issues tab.