What makes eventbrite-mcp notable?

1.5K downloads. Trust evidence available

How should eventbrite-mcp be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

eventbrite-mcp

Query eventbrite.com from a shell — your tickets/orders, your organizations' events and attendees via the documented token API (curl), and public event discovery/search via the fpx browser bridge (the search API is WAF-walled and absent from the documented API). Use when you want Eventbrite data without an MCP server, in a script, or one-shot.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.5k

Updated

Oct 10, 2026

Version

1.1.8

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.5K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.5K downloadsadoption · observed Oct 10, 2026
Latest release: 1.1.8release · observed Oct 9, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17cjx1a349nz5apaqp02vgz4h85728z:eventbrite-mcp

Install using `clawhub skill install s17cjx1a349nz5apaqp02vgz4h85728z:eventbrite-mcp` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/chrischall/eventbrite-mcp before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-chrischall-eventbrite-mcp/snapshot"

Documentation

CLAWHUB

143,580 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: eventbrite
description: "Query eventbrite.com from a shell — your tickets/orders, your organizations' events and attendees via the documented token API (curl), and public event discovery/search via the fpx browser bridge (the search API is WAF-walled and absent from the documented API). Use when you want Eventbrite data without an MCP server, in a script, or one-shot."
---

# Eventbrite access (curl + fpx)

Two surfaces, two tools — match the tool to reachability:

1. **Documented API `https://www.eventbriteapi.com/v3`** — reachable
   server-side with a personal OAuth token. Use plain `curl`. Covers your
   identity, your orders/tickets, organizations you own (events, attendees,
   orders), and any event **by id**. It has **no public event search** —
   Eventbrite removed it from the documented API in 2019.
2. **Consumer site API `https://www.eventbrite.com/api/v3/destination/…`** —
   WAF-blocked for any server-side client (returns an HTML "Whoops!" page).
   Public event **search/discovery** lives only here, so those calls route
   through the user's signed-in browser tab with `fpx`.

## One-time setup

**Token (curl surface):** create a private token at
<https://www.eventbrite.com/platform/api-keys> (free for any Eventbrite
account) and export it as `EVENTBRITE_TOKEN`.

**Bridge (fpx surface):**

```sh
npm install -g @fetchproxy/cli                  # provides `fpx`
fpx profile add eventbrite --domain eventbrite.com
fpx pair -p eventbrite    # prints a pair code → approve in the ContextMint Bridge popup
```

Requires **ContextMint Bridge**
(<https://github.com/nullnet-app/contextmint-bridge/releases> — load the chrome
zip unpacked; use Chrome for now, Safari is not available yet) with site access for
`eventbrite.com` and an open (signed-in for account data) eventbrite.com tab.
Pairing persists after the first approval.
ContextMint Bridge is the fetchproxy extension renamed (same maintainer; source at <https://github.com/nullnet-app/contextmint-bridge> — build it, or verify a release zip with `shasum -a 256 -c contextmint-bridge-chrome-<version>.zip.sha256`).

## Core calls

Token surface — every request is:

```sh
curl -sS "https://www.eventbriteapi.com/v3/users/me/" \
  -H "Authorization: Bearer $EVENTBRITE_TOKEN" | jq
```

Bridge surface — stdout is data only, ready for `jq`:

```sh
fpx get 'https://www.eventbrite.com/api/v3/destination/events/?event_ids=<id>&expand=event_sales_status,primary_venue' \
  -p eventbrite | jq '.events[0]'
```

Ready-to-run request bodies and `jq` recipes: `references/token-api.md`
(curl surface) and `references/discovery-api.md` (fpx surface, incl. event
search). Read the relevant reference before composing a call — the search
body shape and the resolve-location-first rule live there.

## Rules

- **Resolve places before searching**: destination search takes place ids,
  not free-text locations — autocomplete first (see `discovery-api.md`).
- **Pagination**: v3 responses carry a `pagination` envelope;

_meta.json

{
  "ownerId": "kn700jq4sjtf2anb0rk3ft4p7n856872",
  "slug": "eventbrite-mcp",
  "version": "1.1.8",
  "publishedAt": 1791588273865
}

references/discovery-api.md

# Eventbrite discovery API (`www.eventbrite.com/api/v3/destination/…`) — fpx recipes

Public event search/discovery. WAF-blocked server-side; every call here goes
through the fpx bridge (`-p eventbrite`). Request shapes below were captured
live from the site's own network traffic (2026-07-30, web_app discover
v10.14.65).

## CSRF (search POST only)

GETs need nothing extra. The search POST requires the Django CSRF header,
whose value is the `csrftoken` cookie (32 chars, JS-readable). Read it
through the bridge — the profile must declare the cookie scope (see SKILL.md
setup):

```sh
CSRF=$(fpx cookies csrftoken -p eventbrite | jq -r '.csrftoken')
```

If the cookie is absent, load any eventbrite.com page in the browser first.

## Resolve a place id first

Searches take internal place ids (e.g. Charlotte NC = `85981333`), never
place names. The site itself resolves locations via Google Places, but the
scriptable route is the SSR page store: fetch the browse page for the
location slug and pull `placeId` out of the embedded `__SERVER_DATA__`:

```sh
# slug format: <state>--<city> (US) or <country>--<city>
fpx get 'https://www.eventbrite.com/d/co--denver/events/' -p eventbrite \
  | grep -oE '"placeId":"[0-9]+"' | head -1
```

The same SSR page embeds the full first page of results in
`search_data.events` — for a quick "what's on in <city>" that GET alone may
be all you need.

## Event search

```sh
CSRF=$(fpx cookies csrftoken -p eventbrite | jq -r '.csrftoken')
cat > /tmp/eb-search.json <<'EOF'
{
  "browse_surface": "search",
  "event_search": {
    "q": "blues",
    "places": ["85981333"],
    "dates": ["current_future"],
    "dedup": true,
    "page": 1,
    "page_size": 20
  },
  "expand.destination_event": [
    "primary_venue", "image", "ticket_availability",
    "event_sales_status", "primary_organizer"
  ]
}
EOF
fpx post-json 'https://www.eventbrite.com/api/v3/destination/search/' @/tmp/eb-search.json \
  -p eventbrite -H "X-CSRFToken: $CSRF" -H "X-Requested-With: XMLHttpRequest" \
  | jq '.events.results[] | {id, name, start: .start_date, venue: .primary_venue.name, url}'
```

Body knobs (all inside `event_search`, all optional except you want at least
`q` or `places`):

- `q` — keyword text.
- `places` — array of place-id strings (resolve first, above).
- `dates` — array; `"current_future"` plus optionally one of `"today"`,
  `"tomorrow"`, `"this_weekend"`; or `date_range: {from, to}` (ISO dates).
- `tags` — category/format filters: `"EventbriteCategory/<id>"` (103 =
  Music …), `"EventbriteSubCategory/<id>"`, `"EventbriteFormat/<id>"`. Ids
  match the documented API's `/categories/` etc. (see token-api.md).
- `online_events_only` — bool.
- `price` — `"free"` or `"paid"`.
- `page`, `page_size` (site uses 20), `dedup: true`.

Response: `{events: {pagination: {object_count, page_count, continuation},
results: [...]}, ...}` — paginate by incrementing `page`.

## Event detail by id (GET, no CSRF)

```sh
fpx get 'https://www.eventbrite.com/api/v

references/token-api.md

# Eventbrite documented API (`eventbriteapi.com/v3`) — curl recipes

Auth on every call: `-H "Authorization: Bearer $EVENTBRITE_TOKEN"`.
Personal token: <https://www.eventbrite.com/platform/api-keys>.
All endpoints end with a trailing slash — omitting it 301s.

> Verification status (2026-07-30): `eventbriteapi.com` reachability and the
> 401 error envelope are live-verified. Endpoint shapes were live-verified
> through the session-authed www-host variant of the same v3 API
> (`www.eventbrite.com/api/v3/…`): `/users/me/`, `/users/me/orders/`
> envelope, `/users/me/organizations/` envelope, `/categories/`, and
> `/events/<id>/?expand=venue,ticket_availability` on a public event.
> `/ticket_classes/`, `/description/`, `/attendees/`, `/venues/`,
> `/subcategories/`, `/formats/` follow the official API reference but
> weren't exercised — eyeball the first response before building on a field.

Shorthand used below:

```sh
eb() { curl -sS "https://www.eventbriteapi.com/v3$1" -H "Authorization: Bearer $EVENTBRITE_TOKEN"; }
```

## Identity

```sh
eb /users/me/ | jq '{id, name, email: .emails[0].email}'
```

## Your tickets / orders (attendee side)

```sh
# upcoming orders with the event expanded
eb '/users/me/orders/?expand=event&time_filter=current_future' \
  | jq '.orders[] | {id, status, event: .event.name.text, start: .event.start.local}'

# one order with attendees (barcode-level detail)
eb '/orders/<order_id>/?expand=attendees' | jq
```

`time_filter`: `all` | `current_future` | `past`.

## Organizations you belong to (organizer side)

```sh
eb /users/me/organizations/ | jq '.organizations[] | {id, name}'

# events for an org: status live|draft|started|ended|completed|canceled|all
eb '/organizations/<org_id>/events/?status=live&order_by=start_asc' \
  | jq '.events[] | {id, name: .name.text, start: .start.local, url}'

# attendees / orders across the org
eb '/organizations/<org_id>/attendees/?status=attending' | jq '.attendees[] | {profile: .profile.name, email: .profile.email, event_id}'
eb '/organizations/<org_id>/orders/' | jq '.orders[] | {id, email, status}'
```

## Any event by id (works for public events, not just yours)

```sh
eb '/events/<event_id>/?expand=venue,organizer,ticket_availability' \
  | jq '{name: .name.text, start: .start.local, end: .end.local, venue: .venue.name, is_free, status, url}'

eb '/events/<event_id>/ticket_classes/' | jq '.ticket_classes[] | {name, free, cost: .cost.display, on_sale_status}'
eb '/events/<event_id>/description/' | jq -r .description   # full HTML description
eb '/events/<event_id>/attendees/' | jq                     # your own events only
```

Event ids are the long digits in any event URL (`…-tickets-<event_id>`).

## Reference data

```sh
eb /categories/ | jq '.categories[] | {id, name}'
eb /subcategories/ | jq '.subcategories[] | {id, name}'
eb /formats/ | jq '.formats[] | {id, name}'
eb '/venues/<venue_id>/' | jq '{name, address: .address.localized_address_display}'
```

## Pagination

Every

skill-card.md

## Description:

Helps agents retrieve Eventbrite tickets, orders, organizer events and attendees, and discover public events using read-only requests.

This skill is ready for commercial/non-commercial use.

## Publisher:

[chrischall](https://clawhub.ai/user/chrischall)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and Eventbrite users can look up their tickets and orders, review their organizations' events and attendees, and search for public events without an MCP server.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Account tokens, browser cookies, and order or attendee details may be exposed in logs, commits, or shared transcripts.

Mitigation: Keep credentials and personal data out of logs, commits, and shared transcripts; give tools account access only when needed.

Risk: Improvised API calls could change organizer data despite the skill's read-only scope.

Mitigation: Use only the documented read-only recipes; do not add write calls.

## Reference(s):

- [ClawHub skill release](https://clawhub.ai/chrischall/skills/eventbrite-mcp)
- [Eventbrite token API recipes](references/token-api.md)
- [Eventbrite discovery recipes](references/discovery-api.md)
- [ContextMint Bridge](https://github.com/nullnet-app/contextmint-bridge)

## Skill Output:

**Output Type(s):** [Shell commands, Guidance]

**Output Format:** [Markdown with shell commands and JSON response examples]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Read-only recipes; returned account data may include personal information.]

## Skill Version(s):

1.1.8 (source: ClawHub release metadata)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 17h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.