canonical: https://jentic.com/apis/confetti.events/confetti

# Confetti Events API

The Confetti Events API exposes the building blocks of the Confetti event platform so organizers can manage events, tickets, contacts, payments, webhooks, and workspaces from outside the dashboard. It is suited to teams running ticketed events, member-only signups, or branded community events where each workspace contains its own catalog of upcoming events. The surface is concise: a small number of CRUD endpoints per resource plus a webhook registration endpoint for downstream eventing.

## For AI agents

Manage Confetti events, tickets, contacts, payments, webhooks, and workspaces for ticketed and signup-style events.

## Scope

Does not handle full payment processing, video conferencing, or large-venue ticketing - use for Confetti workspace events, tickets, and contacts only.

## Capabilities

- List and retrieve events filtered by signup type and other event metadata
- Issue and look up tickets attached to a contact and event
- Maintain a contact list of attendees and registrants
- Record payments associated with ticketed events
- Subscribe to webhooks for event, ticket, and payment changes
- Read workspace settings to scope subsequent calls

## Use cases

### Ticketed Event Operations

Run ticketed event sales for community, training, or fan events through the Confetti platform. /events lists upcoming events, /tickets issues tickets to contacts, and /payments records the financial side of each ticket. Small organizers and community managers use this to keep ticketing programmatic without building a custom backend.

Example prompt: List events with signup type 'paid' for the next 30 days, then issue one ticket to contact ct_321 for the next-most-recent event

### Attendee Contact Management

Use the contacts surface as a lightweight CRM for attendees who buy tickets across multiple events. The /contacts endpoints store attendee records that tickets reference, so organizers can see every event a contact has joined. This is appropriate for cohorts and member communities where the same people return for several events.

Example prompt: Retrieve contact ct_321 and list all tickets associated with that contact across past and upcoming events

### Webhook-Driven Event Pipeline

Push event and ticket changes into a CRM, marketing platform, or finance system in real time. POST /webhooks registers a subscription, and Confetti delivers structured payloads for ticket and payment events. Marketing and revenue teams use this to trigger post-event nurture, refund flows, or attendance analytics without polling.

Example prompt: Register a webhook with URL https://app.example.com/hooks for ticket.created and payment.succeeded events scoped to workspace ws_12

### Agent-Driven Event Operations via Jentic

Let an AI assistant handle ticketing actions for a community manager in chat. Through Jentic the agent searches by intent, loads the schema for the relevant Confetti operation, and executes the call without the developer wiring auth or pagination. This is suited to small organizing teams that want a chat-driven control surface over their events.

Example prompt: On the prompt 'add Sam to the workshop on June 20th', look up the event id, look up Sam's contact id, and POST /tickets to issue them a ticket

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/events` | List events with filters |
| GET | `/events/{id}` | Retrieve an event |
| POST | `/tickets` | Issue a ticket |
| GET | `/tickets/{id}` | Retrieve a ticket |
| POST | `/contacts` | Create a contact |
| GET | `/contacts/{id}` | Retrieve a contact |
| POST | `/payments` | Record a payment |
| POST | `/webhooks` | Register a webhook |

## Key resources

- **Events** — Event records with signup type and lifecycle
- **Tickets** — Tickets issued to contacts for events
- **Contacts** — Attendee and registrant records
- **Payments** — Payment records associated with tickets and events
- **Webhooks** — Outbound subscriptions for event-platform changes
- **Workspaces** — Tenant configuration for the calling API key

## Why Jentic

- **Setup:** Wiring the Confetti Events API by hand means learning its API key scheme, mapping its event, ticket, and contact resources, and wiring payments and webhooks yourself. Through Jentic you install once, import the Confetti Events API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Confetti puts the event, ticket, and contact ids in the URL path (`/events/{id}`, `/tickets/{id}`, `/contacts/{id}`), so a rule can pin your agent to a specific event, ticket, or contact. You choose the operations it may call, so you can allow event and ticket reads while leaving payments out unless you add them.
- **Credential handling:** Your Confetti API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list workspace events' or 'create a ticket', and Jentic returns the matching Confetti operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Luma** — Modern event hosting platform with calendars, signups, and ticketing
- **Meetup** — Community event platform focused on recurring local groups
- **Calendly** — 1:1 and small-group scheduling with calendar integration

## FAQ

### What authentication does the Confetti Events API use?

The API uses an API key passed in the Authorization header in the form 'apikey your-key'. Through Jentic the key is stored encrypted in the vault and injected at execution time, so the raw key never enters the agent's prompt or logs.

### Can I issue a ticket with the Confetti Events API?

Yes. POST /tickets creates a ticket linked to a contact and an event. You can then retrieve it via GET `/tickets/{id}`, and any subscribed webhook will receive a ticket.created event for downstream processing.

### What are the rate limits for the Confetti Events API?

Confetti applies workspace-level rate limits, typically a couple of hundred requests per minute, with bulk listing operations throttled when pagination depth grows. Agents should add backoff on HTTP 429 responses; Jentic surfaces these as structured errors rather than retrying silently.

### How do I list events through Jentic?

Run the Jentic search query 'list Confetti events', load the returned operation (GET /events), and execute it with optional filters such as filter[signupType]. Pagination is cursor-based and returned in the response metadata.

### Is the Confetti Events API tied to a single workspace?

Yes. Each API key is scoped to a workspace, and GET `/workspaces/{id}` returns the configuration for the workspace tied to the key. To work across multiple workspaces, issue a separate API key per workspace and switch credentials at the agent level.

### Can I record a payment for a ticket?

Yes. POST /payments records a payment row that can be linked to a ticket and event. Confetti is not a full payment processor; the payment record represents the bookkeeping side and would typically be created in response to an upstream payment-processor webhook.

### Can I limit what my agent is allowed to do with the Confetti Events API?

Yes. Because you run Jentic One yourself, your own rules decide which Confetti operations and credentials your agent may use. Confetti puts the event, ticket, and contact ids in the URL path (`/events/{id}`, `/tickets/{id}`, `/contacts/{id}`), so a rule can pin the agent to a specific event, ticket, or contact. You also choose the operations it may call, letting you allow event and ticket reads while leaving POST /payments out unless you add it.