# Eventbrite Event Details Scraper (`epicscrapers/eventbrite-event-details-scraper`) Actor

Extract detailed Eventbrite event data by URL or ID — organizer profiles, ticket pricing, gallery images, discounts, and full descriptions. No login or API key needed. Unlimited events per run.

- **URL**: https://apify.com/epicscrapers/eventbrite-event-details-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 28.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Eventbrite Event Details Scraper

![Eventbrite Event Details Scraper Banner](https://raw.githubusercontent.com/jwlben11/hosted-images/main/eventbrite-event-details-scraper-banner.svg)

**Turn any Eventbrite event URL or ID into rich, structured data in seconds.** Get organizer profiles, ticket pricing, gallery images, discounts, sales urgency signals, and full HTML descriptions — no login, no API key, no rate-limit gymnastics.

If you've ever tried to get real data out of Eventbrite, you know the pain: the official API is locked behind OAuth setup and rate limits, and even then it doesn't expose half of what's actually on the event page. This actor skips all of that. Point it at a URL or an ID, flip on enriched mode if you want the deep stuff, and get clean JSON back — every time, at any scale.

Check out the API section on details about how to use this like an API. It's also very easy to integrate this with n8n, make.com and other automation programs.

### 🚀 Why teams choose this actor

- **Zero setup friction.** No Eventbrite developer account, no OAuth dance, no API key to manage. Paste in URLs or IDs and hit run.
- **Depth the official API can't match.** Enriched mode surfaces organizer follower counts, verified/super-organizer status, refund policies, discount flags, and multi-resolution gallery images — data that simply isn't exposed anywhere else.
- **Built for scale.** Fast mode batches up to 50 events per request for bulk extraction; enriched mode trades some speed for maximum depth on every event. Either way, there's no hard cap on how many events you can process in a run.
- **Always current.** Every run pulls live data straight from Eventbrite, so pricing, availability, and sales status are accurate the moment you scrape — not a stale cache.
- **Clean, predictable output.** Consistent, well-typed JSON fields every time, ready to drop into a spreadsheet, database, or BI tool with no cleanup.

### 🚀 Features

#### Input & Search Features

- **Multiple input formats** — Pass Eventbrite event URLs (e.g. `https://www.eventbrite.com/e/...-tickets-128884694591`) or raw numeric event IDs. Mix both in a single run — the actor figures out which is which.
- **Batch mode (fast)** — Fetches up to **50 events per request** from the Eventbrite API with minimal overhead. Ideal for bulk extraction when you need speed over depth.
- **Enriched mode (deep)** — Enables a second pass that pulls the full event listing page for each event, unlocking richer data: organizer stats, gallery images, structured venue info, discount flags, refund policies, and good-to-know highlights.
- **No authentication** — Runs against public Eventbrite data. No need to create a developer account, generate API keys, or log in.
- **Automatic deduplication** — Duplicate event IDs across inputs are merged into a single result, so you never pay to scrape the same event twice.

#### Output & Data Features

- **Organizer intelligence** — Organizer name, profile image, follower count, total events hosted, years on platform, verified/super-organizer status, and total attendees. Ideal for B2B lead generation and sponsorship prospecting.
- **Ticket availability & pricing** — Minimum and maximum ticket prices with currency, available tickets flag, sold-out detection, all-in-price toggle, and waitlist availability.
- **Discount detection** — Whether the event has BOGO (buy-one-get-one) offers, early bird discounts, or open discount codes.
- **Sales status signals** — Current sales status (on sale, sales ended, etc.) with message code and urgency signals like "sales ending soon" or "early bird available."
- **Full HTML descriptions** — The complete event description with formatting, links, and structure — not just a truncated summary.
- **Gallery images** — All event images in multiple resolutions: original, landscape (1880×940), and square (1880×1880). Plus video links if available.
- **Category & format taxonomy** — Structured category and format data with both internal IDs and human-readable names (e.g. `EventbriteCategory/105` → "Music", `EventbriteFormat/1` → "Conference").
- **Venue & location data** — Venue name, full address object, GPS coordinates (latitude/longitude), and online event detection.
- **Good-to-know highlights** — Duration in minutes, location type (online/in-person), age restrictions, parking info, door open time, and full refund policy details.
- **Privacy & listing flags** — Privacy setting, listing visibility, protected event flag, age restrictions, and refund policy at the event level.
- **Auto-pagination** — Processes any number of input event IDs. No manual batching needed.

### 📥 Input

Configure the actor with the following inputs:

| Input | Required | Default | Description |
|-------|----------|---------|-------------|
| `eventUrls` | No | `[]` | List of Eventbrite event page URLs to scrape |
| `eventIds` | No | `[]` | List of numeric Eventbrite event IDs to scrape |
| `events` | No | `[]` | Combined list of URLs or IDs (alternative to the two above) |
| `enrichDetails` | No | `false` | Enables enriched mode — fetches full event listing data including organizer profiles, gallery images, venue details, discounts, refund policies, and good-to-know info. Slower per event but dramatically richer data |

**Example input:**

```json
{
    "enrichDetails": true,
    "eventIds": [
        "189384"
    ],
    "eventUrls": [
        "https://www.eventbrite.com/e/virtual-january-8-15-22-29-write-to-change-the-world-series-tickets-128884694591"
    ]
}
````

### 📊 What You Get

Every scraped event returns **35+ fields** of structured data in fast mode, and **60+ fields** in enriched mode:

| Field | Description | Example |
|-------|-------------|---------|
| `id` | Unique Eventbrite event identifier | `"128884694591"` |
| `name` | Full event title | `"AI & Machine Learning Conference 2026"` |
| `url` | Public Eventbrite event page URL | `"https://www.eventbrite.com/e/ai-ml-conference-2026-tickets-128884694591"` |
| `summary` | Short event tagline or summary | `"A two-day conference on AI advances and applications"` |
| `status` | Event lifecycle status | `"live"` |
| `isOnlineEvent` | Whether the event is virtual | `false` |
| `timezone` | IANA timezone of the event | `"America/Los_Angeles"` |
| `startDate` | Event start date and time (local) | `"2026-09-15T09:00:00"` |
| `startDateUtc` | Event start date and time (UTC) | `"2026-09-15T16:00:00Z"` |
| `endDate` | Event end date and time (local) | `"2026-09-16T18:00:00"` |
| `endDateUtc` | Event end date and time (UTC) | `"2026-09-17T01:00:00Z"` |
| `currency` | Currency code for pricing | `"USD"` |
| `isFree` | Whether the event is free to attend | `false` |
| `category` | Event category with ID and name | `{"id":"EventbriteCategory/105","name":"Science & Technology"}` |
| `format` | Event format with ID and name | `{"id":"EventbriteFormat/1","name":"Conference"}` |
| `language` | Event language code | `"en-us"` |
| `privacySetting` | Privacy level of the event | `"unlocked"` |
| `organizerId` | Eventbrite organizer profile ID | `"14281588184"` |
| `venueId` | Eventbrite venue ID | `"27689591"` |
| `seriesId` | Event series ID (if part of a series) | `null` |
| `imageId` | Primary image ID on Eventbrite CDN | `"117531419"` |
| `ticketsUrl` | Direct checkout/purchase URL | `"https://www.eventbrite.com/checkout-external?eid=128884694591"` |
| `ticketsBy` | Ticket provider | `"Eventbrite"` |
| `checkoutFlow` | Checkout experience type | `"widget"` |
| `published` | Publication timestamp | `"2026-03-12T03:22:59Z"` |
| `createdAt` | Event creation timestamp | `"2026-03-12T01:32:52Z"` |
| `updatedAt` | Last modification timestamp | `"2026-06-30T22:57:24Z"` |
| `descriptionText` | Plain-text event description | `"A two-day conference covering the latest in AI..."` |
| `descriptionHtml` | Full HTML-formatted event description | `"<div><h2>Agenda</h2><p>Day 1: Keynotes..."` |
| `eventSalesStatus` | Current ticket sales status | `"on_sale"` |
| `eventSalesStatusMessageCode` | Machine-readable sales code | `"tickets_with_sales_ended"` |
| `ticketAvailability` | Ticket pricing and availability details | `{"minimumPrice":{"value":47669,"currency":"USD"},"hasAvailableTickets":true,"isSoldOut":false}` |
| `urgencySignals` | Urgency/sales signals for the event | `{"messages":["salesEndSoon"],"categories":["earlyBird"]}` |
| `organizer` | Full organizer profile (enriched mode) | `{"name":"TechEvents Inc.","numFollowers":1240,"numEvents":879,"verified":true,...}` |
| `venue` | Venue details with address and coordinates (enriched mode) | `{"name":"Moscone Center","address":{"city":"San Francisco","region":"CA",...},"latitude":37.784,"longitude":-122.401}` |
| `discounts` | Discount availability flags | `{"hasBogoTickets":false,"hasEarlyBirdTickets":true,"openDiscount":null}` |
| `goodToKnow` | Additional event logistics info | `{"durationInMinutes":1650,"locationType":"online","refundPolicy":{...},"faqs":[]}` |
| `gallery` | Event images in multiple resolutions | `{"images":[{"originalUrl":"...","landscapeUrl":"...","squareUrl":"..."}],"videos":[]}` |
| `organizationId` | Eventbrite organization ID | `"216668707990"` |
| `isListed` | Whether the event is publicly listed | `true` |
| `isProtectedEvent` | Whether the event requires age verification | `false` |
| `ageRestriction` | Age restriction label | `null` |
| `refundPolicy` | Refund policy type | `null` |

**Example output (one event, enriched mode — partial):**

```json
{
  "id": "1985026080442",
  "name": "AI & Machine Learning Conference 2026",
  "url": "https://www.eventbrite.com/e/ai-ml-conference-2026-tickets-1985026080442",
  "status": "live",
  "isOnlineEvent": false,
  "timezone": "America/Los_Angeles",
  "startDate": "2026-09-15T09:00:00",
  "startDateUtc": "2026-09-15T16:00:00Z",
  "endDate": "2026-09-16T18:00:00",
  "endDateUtc": "2026-09-17T01:00:00Z",
  "currency": "USD",
  "isFree": false,
  "category": {
    "id": "EventbriteCategory/105",
    "name": "Science & Technology"
  },
  "format": {
    "id": "EventbriteFormat/1",
    "name": "Conference"
  },
  "descriptionText": "Join 2,000+ engineers, researchers, and business leaders for two days of AI innovation.",
  "descriptionHtml": "<div><h2>Agenda</h2><p>Day 1: Keynotes from industry leaders...</p></div>",
  "ticketAvailability": {
    "minimumPrice": { "currency": "USD", "value": 47669 },
    "maximumPrice": { "currency": "USD", "value": 53005 },
    "hasAvailableTickets": true,
    "isSoldOut": false,
    "useAllInPrice": true,
    "showWaitList": false
  },
  "organizer": {
    "id": "14281588184",
    "name": "TechEvents Inc.",
    "imageUrl": "https://img.evbuc.com/...",
    "numFollowers": 1240,
    "numEvents": 879,
    "hostingSince": 109,
    "verified": true,
    "superOrganizer": false,
    "totalAttendees": 45200
  },
  "venue": {
    "id": "27689591",
    "name": "Moscone Center",
    "address": {
      "city": "San Francisco",
      "region": "CA",
      "country": "US",
      "streetAddress": "747 Howard Street",
      "postalCode": "94103"
    },
    "latitude": 37.784,
    "longitude": -122.401
  },
  "gallery": {
    "images": [
      {
        "id": "117531419",
        "originalUrl": "https://img.evbuc.com/...original...",
        "landscapeUrl": "https://img.evbuc.com/...landscape...",
        "squareUrl": "https://img.evbuc.com/...square..."
      }
    ],
    "videos": []
  },
  "discounts": {
    "hasBogoTickets": false,
    "hasEarlyBirdTickets": true,
    "openDiscount": null
  },
  "goodToKnow": {
    "durationInMinutes": 1650,
    "locationType": "in-person",
    "refundPolicy": {
      "policyType": "no_refunds",
      "isRefundAllowed": false,
      "validDays": 0,
      "refundRequestOrganizer": false
    },
    "faqs": []
  }
}
```

### 🛠️ How it works

1. **You provide input** — a list of event URLs, event IDs, or a mix of both.
2. **The actor extracts numeric IDs** from any URLs and deduplicates the full list, so you never scrape the same event twice.
3. **Fast mode (default)** batches requests to Eventbrite's public API, up to 50 events per call, returning 35+ core fields per event.
4. **Enriched mode** (`enrichDetails: true`) adds a second pass per event, pulling the full listing page to unlock organizer profiles, galleries, venue detail, discounts, refund policies, and urgency signals — 60+ fields total.
5. **Results stream to your dataset** as they're scraped, so you can start working with early results before the run finishes.
6. **Export or integrate** — pull the dataset down in JSON, CSV, Excel, XML, HTML Table, or RSS, or connect it directly to the Apify API, Google Sheets, a webhook, or your own pipeline.

### 🧭 Getting started

1. Open the actor on Apify and click **Try for free** (or **Run**).
2. Paste your event URLs into `eventUrls`, your event IDs into `eventIds`, or mix both into `events`.
3. Toggle `enrichDetails` to `true` if you want organizer stats, galleries, venue detail, and discount/urgency data. Leave it `false` for a fast, lightweight pass.
4. Click **Start** and watch results populate the dataset in real time.
5. Export your results or connect the dataset to your downstream tool of choice.

**Tip:** For very large batches, start with fast mode to get broad coverage quickly, then re-run just the events you care about most with `enrichDetails: true` to fill in the deeper fields.

### 🔗 Related Actors

Looking for more event and marketplace data? Check out these related actors from our collection:

| Actor | Description |
|-------|-------------|
| [**Meetup Events Scraper**](https://apify.com/epicscrapers/meetup-events-scraper) | Search and extract 20+ data fields from Meetup.com events by keyword, location, category, date range, and format |
| [**Meetup Groups Search Scraper**](https://apify.com/epicscrapers/meetup-groups-finder) | Find Meetup groups by keyword, location, and category with contact info, member counts, topic tags, and GPS coordinates |
| [**Meetup Group Details Scraper**](https://apify.com/epicscrapers/meetup-group-details-scraper) | Extract full details of Meetup groups by URL including member count, description, organizer info, and social media links |

### 💡 Use Cases

#### 📊 Event Market Research & Competitive Intelligence

**A market research analyst at an event management firm needs to understand the competitive landscape across North America.** Instead of manually browsing Eventbrite city by city, they compile a list of competitor events by collecting URLs from their competitors' social media, email campaigns, and partner sites.

By feeding these URLs into the Eventbrite Event Details Scraper with `enrichDetails: true`, the analyst gets structured data on every event — including `startDate`, `endDate`, `category`, `format`, and `ticketAvailability` pricing. They can analyze what categories competitors prioritize, how they price tickets across markets, and which formats (conference vs. workshop vs. networking) are gaining traction.

The analyst can cross-reference `organizer.numEvents` and `organizer.totalAttendees` to gauge the scale and experience of each organizing team, identify fast-growing players, and spot gaps in the market where no one is competing yet. The result: a data-driven competitive strategy, not a gut-feel one.

#### 🎯 B2B Sponsorship & Partnership Prospecting

**A sponsorship sales director at a corporate event sponsor needs to find high-value events to sponsor.** Rather than waiting for inbound proposals, they take a proactive approach: they know which mid-size tech conferences attract their target audience, and they scrape those events' data from Eventbrite.

The actor returns rich organizer profiles with `organizer.numFollowers`, `organizer.numEvents`, `organizer.verified`, and `organizer.superOrganizer` flags — all signals of organizer quality and reach. The `ticketAvailability` pricing (minimum and maximum price values) gives an instant read on the event's ticket economics: are they selling $50 community tickets or $1,500 enterprise passes?

The director can also check `discounts.hasEarlyBirdTickets` and `urgencySignals` to understand the organizer's sales strategy. Events with active urgency signals (like "sales ending soon") are actively marketing — a good sign they have budget for partnerships. The `gallery` images show the production quality of past events. The outcome: a prioritized, data-backed list of sponsorship targets, reducing outreach time by **70%** and increasing conversion rates.

#### 🏢 Venue Operations & Hospitality Analytics

**A venue operations manager at a mid-size convention center wants to understand what types of events book competing venues in their city.** They build a list of Eventbrite event URLs at venues like the convention center, hotels, and theaters in their region.

The Eventbrite Event Details Scraper returns structured `venue` objects with full addresses, `latitude`, `longitude`, and `name`. The manager can map all events to physical locations, analyze `category` and `format` distributions by venue, and track `startDate` and `endDate` patterns to understand booking cycles.

`goodToKnow.locationType` tells them whether events are in-person, online, or hybrid — critical for understanding the post-pandemic event mix. `goodToKnow.durationInMinutes` helps them calculate average event length and optimize their own scheduling. The `ticketAvailability` data reveals whether competing venues attract high-ticket-price events (premium conferences) or free community events. This intelligence helps the manager adjust their own pricing, marketing, and amenities strategy — and identify underserved event categories to target.

#### 📅 Content & Editorial Calendar Planning

**A content marketing manager at a B2B SaaS company needs to plan a quarterly content calendar around industry events.** Their audience attends conferences, workshops, and meetups — and they want to publish content that aligns with those events.

By scraping Eventbrite for relevant event URLs by topic (AI, SaaS, developer tools, etc.), they extract `startDate`, `endDate`, `name`, `descriptionText`, and `category` for every event. They can now map editorial content to the event calendar: publish a "what to expect" post 3 weeks before the event, a "meet us there" post 1 week before, and a recap post 1 week after.

The `descriptionHtml` field gives them the full event description including speakers, agenda, and themes — rich material for content inspiration and SEO keyword targeting. The `organizer` profile shows them which organizers produce the most events, so they can prioritize building relationships with high-volume players. The result is a year-round content engine driven by real event data, not guesswork.

#### 🌐 Event Aggregator & Community Platform Development

**A startup founder is building a city-wide event discovery platform that aggregates data from multiple sources.** Eventbrite is one of the largest event databases, but their API has rate limits, requires OAuth setup, and doesn't expose all the fields needed for a rich user experience.

Using the Eventbrite Event Details Scraper, the founder can extract complete event data — `name`, `url`, `descriptionHtml`, `startDate`, `startDateUtc`, `endDate`, `timezone`, `venue` with full address and GPS coordinates, `category`, `format`, `isOnlineEvent`, `gallery.images`, `currency`, `isFree`, and `ticketAvailability` pricing — all in one API call per event.

The `privacySetting` and `isListed` flags help the founder decide which events to display. `language` enables multi-language filtering. The gallery images provide visual content for the platform's event cards. With scheduled runs, the founder can keep their event database fresh by re-scraping events on a regular cadence, ensuring that `ticketAvailability.hasAvailableTickets` and `eventSalesStatus` reflect the latest state. The result is a competitor-grade event platform built in weeks, not months.

#### 📊 Academic Research & Event Trend Analysis

**An urban studies researcher is studying the post-pandemic recovery of in-person events in major US cities.** They need historical and current data on event volume, formats, pricing, and geographic distribution — at scale.

The researcher collects Eventbrite event URLs from multiple cities and runs them through the Eventbrite Event Details Scraper. The structured output gives them `isOnlineEvent` (to classify online vs. in-person), `format` (to track the rise of hybrid vs. purely in-person formats), `venue.address` and `latitude`/`longitude` (for geospatial analysis), and `ticketAvailability` pricing (to study economic accessibility).

With `createdAt` and `published`, the researcher can order events by their appearance on the platform. `organizer.numEvents` and `organizer.hostingSince` help distinguish established organizers from newcomers — a proxy for market maturity. The clean, machine-readable JSON output is ready for import into statistical software (R, Python pandas) for regression analysis, time-series modeling, and geospatial visualization. The researcher publishes findings in peer-reviewed journals with a fully reproducible data pipeline.

### ❓ Frequently Asked Questions

#### How do I provide event URLs or IDs to scrape?

You can pass event URLs (e.g., `https://www.eventbrite.com/e/event-name-tickets-128884694591`) in the `eventUrls` field, or raw numeric event IDs in the `eventIds` field. You can also use the combined `events` field that accepts both formats. The actor automatically extracts the numeric ID from URLs and deduplicates any repeats.

#### Is there a limit on how many events I can scrape per run?

There is no hard limit. You can pass as many event URLs or IDs as you need. The actor will process them all in a single run. For large batches (thousands of events), enriched mode will be slower since it fetches each event's full listing page individually. Fast mode uses batch requests (up to 50 events at a time) and is recommended for bulk extraction when you don't need the richest data on every event.

#### Do I need an Eventbrite account, API key, or login?

No. The actor accesses only publicly available Eventbrite event data and requires zero authentication. No Eventbrite developer account, no OAuth tokens, no API key, no login. Just provide the URLs or IDs and run.

#### What geographical coverage does this actor have?

Eventbrite operates globally across **180+ countries**. Since this actor extracts data from specific Eventbrite event pages (by URL), it covers any event anywhere in the world that has a public Eventbrite page. There are no location restrictions. Whether it's a tech conference in San Francisco, a cooking class in Tokyo, a music festival in Berlin, or a charity run in São Paulo — if it's on Eventbrite, this actor can scrape it.

#### How fresh is the data?

The data is fetched live every time you run the actor. Each run queries Eventbrite's current data for the events you specify, so you always get up-to-date information on pricing, availability, dates, and status. The `updatedAt` and `published` timestamps are included in the output so you can track when the event was last modified on Eventbrite.

#### What formats can I export the data in?

Apify's platform lets you export datasets in **JSON, CSV, Excel (XLSX), XML, HTML Table**, and **RSS** formats. You can also access the data via the Apify API for integration into your own pipelines, connect it to Google Sheets, trigger webhooks, or push it to cloud storage.

#### How is this different from the Eventbrite API?

The official Eventbrite API requires you to register a developer account, generate OAuth tokens, navigate rate limits, and build integration code. This actor requires none of that. Additionally, the Eventbrite API does not expose many of the fields this actor returns in enriched mode — such as full organizer profiles (follower counts, total events, verified status), gallery images in multiple resolutions, good-to-know highlights (refund policy, duration, FAQs), discount flags (BOGO, early bird, open discounts), and urgency signals. This actor combines data from multiple internal Eventbrite endpoints to give you a more complete picture of each event than the public API provides alone.

#### What are alternatives to Eventbrite for event discovery?

Eventbrite is the largest self-service event ticketing platform globally, but alternatives include **Meetup.com** (community-focused events and recurring groups), **Luma** (networking and tech events), **Eventbrite's own API** (for programmatic access with rate limits), and **Bizzabo** (enterprise event management). If you're looking for community-driven events, check out our [Meetup Events Scraper](https://apify.com/epicscrapers/meetup-events-scraper) as a companion tool.

#### Can I scrape the same events periodically to track changes?

Yes. Apify's platform supports **scheduled runs** via cron expressions. You can set up weekly or daily runs to re-scrape the same set of event URLs and compare outputs over time. This is useful for tracking price changes (`ticketAvailability`), availability changes (`hasAvailableTickets`, `isSoldOut`), and status changes (`eventSalesStatus`) as events move from "on sale" to "sales ended."

#### What happens if I pass an invalid or non-existent event ID?

The actor skips events it can't resolve and continues processing the rest of your list, so one bad ID or a removed listing won't stop the whole run. Check the run log for any events that were skipped.

#### Can I run this on a schedule and only get new or changed data?

Yes — pair a scheduled run with your own diffing logic downstream (comparing `updatedAt`, `eventSalesStatus`, and `ticketAvailability` against your last snapshot) to build a change-tracking pipeline without re-processing everything from scratch each time.

### SEO Keywords

eventbrite scraper, eventbrite data extraction, eventbrite event details scraper, scrape eventbrite events, eventbrite event data API, eventbrite organizer data, eventbrite ticket prices scraper, eventbrite gallery scraper, eventbrite event description scraper, extract eventbrite event details, eventbrite event details by URL, eventbrite enriched event data, eventbrite event metadata extractor, eventbrite bulk event scraper, eventbrite event catalog scraper, apify eventbrite actor, eventbrite scraper apify, eventbrite data pipeline, eventbrite event intelligence, eventbrite sponsorship lead gen, eventbrite market research tool, eventbrite competitor analysis, eventbrite venue data, eventbrite discount detection, eventbrite sales status tracker, eventbrite ticket availability scraper, eventbrite organizer profile scraper, eventbrite html description extractor, scrape multiple eventbrite events, eventbrite event monitoring, eventbrite API alternative, eventbrite without API key, eventbrite unlimited scraper, eventbrite enriched mode

### ⚠️ Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Eventbrite, Inc., or any of their subsidiaries**. All trademarks are the property of their respective owners.

This Actor accesses only publicly available event data on `eventbrite.com`. You are solely responsible for ensuring your use complies with the site's Terms of Service and applicable laws.

# Actor input Schema

## `eventUrls` (type: `array`):

List of Eventbrite event URLs to scrape

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

List of Eventbrite event IDs (numeric) to scrape

## `enrichDetails` (type: `boolean`):

If enabled, fetches additional details (pricing, organizer stats, full HTML description, gallery, venue, discounts) from the BFF endpoint. Slower as each event is fetched individually.

## Actor input object example

```json
{
  "eventUrls": [
    "https://www.eventbrite.com/e/virtual-january-8-15-22-29-write-to-change-the-world-series-tickets-128884694591"
  ],
  "eventIds": [],
  "enrichDetails": false
}
```

# Actor output Schema

## `results` (type: `string`):

Link to the dataset of scraped records

# 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 = {
    "eventUrls": [
        "https://www.eventbrite.com/e/virtual-january-8-15-22-29-write-to-change-the-world-series-tickets-128884694591"
    ],
    "eventIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/eventbrite-event-details-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 = {
    "eventUrls": ["https://www.eventbrite.com/e/virtual-january-8-15-22-29-write-to-change-the-world-series-tickets-128884694591"],
    "eventIds": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "eventUrls": [
    "https://www.eventbrite.com/e/virtual-january-8-15-22-29-write-to-change-the-world-series-tickets-128884694591"
  ],
  "eventIds": []
}' |
apify call epicscrapers/eventbrite-event-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=epicscrapers/eventbrite-event-details-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Event Details Scraper",
        "description": "Extract detailed Eventbrite event data by URL or ID — organizer profiles, ticket pricing, gallery images, discounts, and full descriptions. No login or API key needed. Unlimited events per run.",
        "version": "0.0",
        "x-build-id": "0c0ulLSHhcvJ6AZi9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~eventbrite-event-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-eventbrite-event-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/epicscrapers~eventbrite-event-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-eventbrite-event-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/epicscrapers~eventbrite-event-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-eventbrite-event-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "List of Eventbrite event URLs to scrape",
                        "items": {
                            "type": "string"
                        }
                    },
                    "eventIds": {
                        "title": "Event IDs",
                        "type": "array",
                        "description": "List of Eventbrite event IDs (numeric) to scrape",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichDetails": {
                        "title": "Enrich Details",
                        "type": "boolean",
                        "description": "If enabled, fetches additional details (pricing, organizer stats, full HTML description, gallery, venue, discounts) from the BFF endpoint. Slower as each event is fetched individually.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```