ScreenshotNeo

BlogHow-to

How to Scrape Eventbrite Events and Listings

Use Eventbrite’s OAuth API to collect event data, paginate safely, export JSON or CSV, and stay within Eventbrite’s terms.

By the ScreenshotNeo team30 September 20268 min read

How to Scrape Eventbrite Events and Listings

Direct answer: Use Eventbrite’s official REST API with OAuth2. Do not crawl or scrape eventbrite.com HTML: Eventbrite’s Terms prohibit scraping, crawling, and automated extraction from its sites. The legacy public Event Search endpoint was shut down on December 12, 2019.

The API returns JSON. A dependable collector authenticates on the server, requests the current event resource available to its account, follows continuation-token pagination until has_more_items is false, normalizes fields such as title, URL, status, and times, and stores the source URL for traceability.

What you can collect

Event objects can include the event name, summary, listing URL, start and end times, creation and change timestamps, publication state, lifecycle status, currency, and whether the event is online. Status values include draft, live, started, ended, completed, and canceled.

Field Use
id Stable identifier for deduplication.
name Display title and search text.
summary Short description, when present.
url Canonical Eventbrite listing link.
start, end Scheduled times, including timezone data returned by the API.
status Lifecycle filtering and synchronization.
currency Money formatting for downstream displays.
online_event Separates online events from venue-based events.
created, changed, published Incremental synchronization and audit history.

API access, authorization, and compliance

  1. Open Eventbrite Account Settings, choose API Keys, and create an API key. Eventbrite may ask for application details and approve the key by email.
  2. For a personal integration, use the private token documented by Eventbrite. For an application serving multiple Eventbrite users, implement OAuth2: send users to the authorization endpoint, then exchange the returned code at https://www.eventbrite.com/oauth/token.
  3. Keep private tokens on your server. Never place them in browser JavaScript, mobile bundles, public repositories, or client-side configuration.
  4. Choose a current API resource that your account is authorized to access. Eventbrite’s API documentation is REST-based, uses OAuth2, and returns JSON; resource availability depends on the account and application.
  5. If your application displays API-derived listing content, show the event title and a direct link to the Eventbrite page. Recheck the current API documentation and Terms before launch because endpoints and policy text can change.

Eventbrite’s Terms of Service section 13.1 says: “You have no right to use, and you agree not to, scrape, crawl, or employ any automated means to extract data from the Sites.” The supported route is the API, not HTML parsing.

An authorized API request becomes a sequence of complete event pages through continuation-token pagination.
An authorized API request becomes a sequence of complete event pages through continuation-token pagination.

Pagination with continuation tokens

Every list response is a page. Inspect pagination.has_more_items (or the equivalent pagination object documented for the resource), copy its continuation token, and send that token with the next request. Stop when has_more_items is false or no token is returned. Save the token and retrieval timestamp after each successful page so an interrupted job can resume.

Complete collection example

The examples below use an EVENTS_ENDPOINT environment variable because Eventbrite has multiple event resources and the correct resource depends on your account. Set it to the current endpoint shown in Eventbrite’s API documentation for your use case.

cURL: fetch one page

export EVENTBRITE_TOKEN='YOUR_PRIVATE_TOKEN'
export EVENTS_ENDPOINT='https://www.eventbriteapi.com/v3/REPLACE_WITH_DOCUMENTED_EVENT_RESOURCE/'

curl --fail-with-body --silent --show-error \
  -H "Authorization: Bearer ${EVENTBRITE_TOKEN}" \
  -H "Accept: application/json" \
  "${EVENTS_ENDPOINT}?token=YOUR_CONTINUATION_TOKEN"

For the first page, omit the token query parameter. Use the continuation token returned by the preceding response for later pages.

Python: follow every page and write JSON

import json
import os
import time
import requests

endpoint = os.environ["EVENTS_ENDPOINT"]
private_token = os.environ["EVENTBRITE_TOKEN"]
headers = {
    "Authorization": f"Bearer {private_token}",
    "Accept": "application/json",
}

records = []
continuation = None
retrieved_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())

while True:
    params = {}
    if continuation:
        params["continuation"] = continuation

    response = requests.get(endpoint, headers=headers, params=params, timeout=60)
    response.raise_for_status()
    page = response.json()

    for event in page.get("events", []):
        records.append({
            "id": event.get("id"),
            "name": event.get("name"),
            "summary": event.get("summary"),
            "url": event.get("url"),
            "start": event.get("start"),
            "end": event.get("end"),
            "created": event.get("created"),
            "changed": event.get("changed"),
            "published": event.get("published"),
            "status": event.get("status"),
            "currency": event.get("currency"),
            "online_event": event.get("online_event"),
        })

    pagination = page.get("pagination", {})
    if not pagination.get("has_more_items"):
        break
    continuation = pagination.get("continuation")
    if not continuation:
        raise RuntimeError("API reported more items but returned no continuation token")

with open("eventbrite-events.json", "w", encoding="utf-8") as output:
    json.dump({"retrieved_at": retrieved_at, "events": records}, output, ensure_ascii=False, indent=2)

print(f"Saved {len(records)} events")

Node.js: follow every page and write JSON

import { writeFile } from 'node:fs/promises';

const endpoint = process.env.EVENTS_ENDPOINT;
const token = process.env.EVENTBRITE_TOKEN;
if (!endpoint || !token) throw new Error('Set EVENTS_ENDPOINT and EVENTBRITE_TOKEN');

const events = [];
let continuation;

while (true) {
  const url = new URL(endpoint);
  if (continuation) url.searchParams.set('continuation', continuation);

  const response = await fetch(url, {
    headers: {
      Authorization: `Bearer ${token}`,
      Accept: 'application/json'
    }
  });
  if (!response.ok) {
    throw new Error(`Eventbrite API returned ${response.status}: ${await response.text()}`);
  }

  const page = await response.json();
  for (const event of page.events ?? []) {
    events.push({
      id: event.id,
      name: event.name,
      summary: event.summary,
      url: event.url,
      start: event.start,
      end: event.end,
      created: event.created,
      changed: event.changed,
      published: event.published,
      status: event.status,
      currency: event.currency,
      online_event: event.online_event
    });
  }

  const pagination = page.pagination ?? {};
  if (!pagination.has_more_items) break;
  continuation = pagination.continuation;
  if (!continuation) throw new Error('More items reported without a continuation token');
}

await writeFile('eventbrite-events.json', JSON.stringify({ events }, null, 2));
console.log(`Saved ${events.length} events`);

JSON and CSV export

JSON preserves nested start/end objects and any optional fields. For CSV, flatten nested values and quote every field that can contain commas, quotes, or line breaks. Keep the original JSON response as an audit copy, then derive CSV from the normalized records.

import csv, json

with open("eventbrite-events.json", encoding="utf-8") as source:
    rows = json.load(source)["events"]

columns = ["id", "name", "summary", "url", "status", "currency", "online_event", "start", "end"]
with open("eventbrite-events.csv", "w", newline="", encoding="utf-8") as target:
    writer = csv.DictWriter(target, fieldnames=columns)
    writer.writeheader()
    for row in rows:
        flat = dict(row)
        flat["start"] = json.dumps(row.get("start"), ensure_ascii=False)
        flat["end"] = json.dumps(row.get("end"), ensure_ascii=False)
        writer.writerow(flat)

Expansions, filtering, and synchronization

  • Expansions: Request related organizers or venues only when the output needs them. Expansions add work to each request and can slow collection.
  • Filtering: Prefer filters supported by the selected API resource. Filter lifecycle status and changed timestamps after retrieval when server-side filters are unavailable.
  • Incremental jobs: Store event ID, changed timestamp, source URL, response version, and retrieval time. On later runs, fetch changed records and upsert by ID.
  • Attribution: Preserve the direct Eventbrite URL and display the title whenever API content appears in your application.

Edge cases and reliability

  • Events can be canceled, ended, or completed after you first collect them. Do not treat an old record as permanently active.
  • Optional fields may be absent or null. Code defensively instead of assuming every event has a summary, venue, currency, or online flag.
  • Time values include timezone information. Parse them as timezone-aware values and store the original representation.
  • Persist pagination progress after each page. If a job fails, resume from the saved continuation token rather than duplicating the entire run.
  • Use bounded timeouts, structured logs, and retry handling for transient HTTP failures. Do not blindly retry authentication or permission errors.
  • Keep raw responses for debugging, but restrict access because they may contain data your application is not allowed to redistribute.

Performance and cost notes

Request only fields and expansions needed by the product. Larger pages and related-object expansions increase transfer and processing time. Parallelize only independent jobs; pagination within one listing must remain ordered by its continuation token. Eventbrite’s public materials do not establish a universal request quota in this guide, so read the limits attached to your account and implement backoff when the API signals throttling. Cache normalized records and use changed timestamps to avoid repeatedly downloading unchanged events.

Troubleshooting

Symptom Likely cause Fix
401 Unauthorized Missing, expired, or malformed bearer token. Regenerate or refresh credentials, send Authorization: Bearer ..., and keep the token server-side.
403 Forbidden The token or application lacks access to the selected resource. Choose a resource authorized for the account and complete the required approval or OAuth scope.
404 Not Found Obsolete or incorrect endpoint. Use the current resource documented for your account; do not use the retired public Event Search endpoint.
Only the first page is saved Continuation token was ignored. Check has_more_items, pass the returned continuation token, and loop until it is false.
Duplicate events Job restarted without a checkpoint or used append-only storage. Upsert by event ID and persist the last successful page token.
Broken CSV columns Unquoted commas, quotes, or line breaks in names and summaries. Use a CSV library and flatten nested objects explicitly.
Incorrect times Timezone information was discarded. Store timezone-aware timestamps and convert only at presentation time.
Policy concern HTML crawling or displaying API content without attribution. Use the API, follow the Terms, show the event title and direct Eventbrite link, and review current policy before launch.

Or skip the browser setup

If you need a visual snapshot of a page you are allowed to access, ScreenshotNeo provides a single-call screenshot API. It is useful for QA, archival previews, and permitted pages; it does not replace Eventbrite’s API for structured event data.

A permitted visual capture can remove common overlays before rendering the final image.
A permitted visual capture can remove common overlays before rendering the final image.

Cookie banners, newsletter popups, and chat widgets are removed before the shot. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers. An MCP server lets Claude, Cursor, and other MCP clients take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.

See the ScreenshotNeo API documentation for all options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://www.eventbrite.com -o shot.webp
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://www.eventbrite.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://www.eventbrite.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Create a free ScreenshotNeo account with 1,000 screenshots per month and no card.

FAQ

Is there an Eventbrite events API?

Yes. Eventbrite documents a REST API using OAuth2 and JSON responses. Select the resource your account is authorized to use.

Can I scrape Eventbrite’s public HTML?

Eventbrite’s Terms prohibit scraping, crawling, and automated extraction from its sites. Use the API instead.

How do I get every event?

Follow continuation-token pagination, checking has_more_items on every response until it becomes false.

Can I display the collected listings?

Follow the API Terms: display the event title and a direct link to the corresponding Eventbrite page, and verify the current terms before release.

Why did an old tutorial stop working?

The legacy public Event Search endpoint was shut down on December 12, 2019. Replace obsolete instructions with the current authorized API resources.