Eventtia API V3

Open by design. Built to integrate.

Every event operation is an API endpoint. Registration, check-in, communications, matchmaking, analytics, payments. Headless deployments, real-time webhooks, server-to-server auth. The most comprehensive event API in the industry — production at connect.eventtia.com.

Read the docs → Talk to us
POST /api/v3/m2m-auth 
# Authenticate, get a Bearer token, start integrating
curl https://connect.eventtia.com/api/v3/m2m-auth \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "<your_client_id>",
    "client_secret": "<your_client_secret>"
  }'

# Response
{
  "access_token": "eyJhbGciOi...",
  "scope": "events:read events:write attendees:*",
  "expires_in": "2026-06-16T18:00:00Z",
  "token_type": "Bearer"
}

Powering integrations at

Nike Cartier Sony Tiffany & Co. IWC Schaffhausen Van Cleef & Arpels Ralph Lauren Bioderma Pernod Ricard
What becomes possible

Four shapes of integration. All open.

Eventtia is event infrastructure built API-first. Customers operate inside their own systems, push real-time data into the rest of their stack, automate workflows on top of the platform, and increasingly let AI agents do all three.

01 / Headless

Embed Eventtia in your own digital surfaces.

Attendees register inside your site, your app, your branded checkout — never seeing Eventtia. The full registration engine sits behind the API. Nike embedded Eventtia across Nike.com, the iOS app, and the Android app in under 90 days, running 5,000+ events per year from inside their own infrastructure.

POST /api/v3/events/{event_id}/attendees 
curl -X POST https://connect.eventtia.com/api/v3/events/12345/attendees \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "type": "attendees",
      "attributes": {
        "email": "[email protected]",
        "first_name": "Maya",
        "last_name": "Khan",
        "attendee_type_id": 42
      }
    }
  }'
02 / Webhooks

Push every event into the rest of your stack, in real time.

Account-level and event-level webhooks fire the moment something happens: attendee created, payment confirmed, badge printed, meeting accepted. Filter account-level webhooks to specific administrative areas. Your CRM, warehouse, BI dashboard, and marketing automation see the same row at the same time.

POST /api/v3/account-webhooks 
curl -X POST https://connect.eventtia.com/api/v3/account-webhooks \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "target_url": "https://hooks.yourcompany.com/eventtia",
    "trigger": "attendee_created",
    "administrative_area_ids": [3, 7]
  }'
03 / Custom workflows

Build automations the platform doesn't ship.

The API exposes the granular operations — approve a registration, update workshop assignments, mark an attendee for badge printing, send a survey. Compose them into the workflows your event team actually needs. Offline batch endpoints handle the on-site case where connectivity drops at the door.

POST /api/v3/events/{event_id}/checkpoints/{checkpoint_id}/batch-checkin 
# Batch check-in 200 attendees collected while offline
curl -X POST "$URL/batch-checkin" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "checkpoints": [
      { "attendee_uuid": "abc-123", "checkpoint_id": 9,
        "action": "checkin", "action_at": "2026-05-22T09:14:11Z" },
      { "attendee_uuid": "def-456", "checkpoint_id": 9,
        "action": "checkin", "action_at": "2026-05-22T09:14:18Z" }
    ]
  }'
04 / AI agents

Let AI agents operate the platform natively.

The first open Model Context Protocol server for event management. Agents discover what's available, call endpoints, and orchestrate workflows without bespoke integration. Create an event, pull registration stats, send a targeted reminder — conversational, not programmatic. Detail in the MCP section below.

MCP mcp.eventtia.com 
# In your agent config (Claude, ChatGPT, custom)
{
  "mcpServers": {
    "eventtia": {
      "url": "https://mcp.eventtia.com",
      "headers": {
        "Authorization": "Bearer $TOKEN"
      }
    }
  }
}
The API surface

Every event operation, as an endpoint.

110+ endpoints across the platform, grouped the way an integrator thinks about them. Each one documented in the API reference with request/response schemas, auth modes, caching behavior, and code samples.

Events

7 endpoints
  • POST /events
  • GET /events
  • GET /events/{id}
  • PATCH /events/{id}
  • GET /events/{id}/ticket-stats
  • GET /events/{id}/workshops-stats
  • GET /accounts/{uuid}/events

Attendees

13 endpoints
  • POST /events/{id}/attendees
  • GET /events/{id}/attendees
  • GET /attendees/{id}
  • PATCH /attendees/{id}
  • POST /attendees/{id}/cancel
  • POST /attendees/{id}/print
  • … lookup by email, archive, workshop updates

Check-in & Checkpoints

7 endpoints
  • POST /attendees/{id}/check-in
  • POST /checkpoints/{id}/check-in
  • POST /checkpoints/{id}/check-out
  • POST /batch-checkin
  • GET /checkpoints/{id}/check-ins
  • … capacity, allowed types, offline sync

Business conferences matchmaking

25+ endpoints
  • GET /events/{id}/business-conferences
  • POST /meeting-requests
  • PATCH /meeting-requests/{id}/approve
  • GET /participants/{id}/agenda
  • GET /meetings/{id}/ics
  • … ratings, blacklists, unavailable hours, ICS exports

Workshops & speakers

22 endpoints
  • POST /workshops
  • POST /workshop-definitions
  • POST /attendees/{id}/workshops
  • GET /events/{id}/available-slots
  • … speakers, categories, definitions, exports

Payments & add-ons

7 endpoints
  • GET /events/{id}/purchase-items
  • GET /coupons/{id}
  • POST /coupons/{id}/validate
  • GET /attendees/{id}/purchase-items
  • … pricing tiers, discounts, attendee add-ons

Engagement Q&A · surveys

7 endpoints
  • GET /events/{id}/qa-sessions
  • POST /qa-sessions/{id}/questions
  • POST /qa-questions/{id}/like
  • GET /surveys/{id}
  • POST /surveys/{id}/answers

Webhooks

6 endpoints
  • POST /account-webhooks
  • POST /events/{id}/event-webhooks
  • GET /account-webhooks
  • DELETE /account-webhooks
  • … per-trigger, area-filtered, idempotent

Users, roles, permissions

6 endpoints
  • POST /users
  • GET /users
  • GET /users/{id}/permissions
  • GET /roles
  • … SSO, archive, fine-grained perms

Sponsors

3 endpoints
  • GET /events/{id}/sponsors
  • GET /sponsors/{id}
  • PATCH /sponsors/{id}

Geo & reference data

6 endpoints
  • GET /countries
  • GET /regions
  • GET /cities
  • GET /timezones
  • … cached 15 days, public

Authentication

3 modes
  • POST /m2m-auth server-to-server
  • POST /authenticate backoffice user
  • Attendee tokens attendee-facing apps

See every endpoint in the reference →

Authentication

Three auth modes. One model per integration shape.

Server-to-server backends, backoffice user actions, and attendee-facing apps each get their own token type. JWT throughout. Tokens carry scopes and expirations; the API enforces them at the endpoint level.

01 / Machine-to-machine

OAuth client credentials.

For backend integrations — CRM sync, warehouse pipelines, scheduled jobs. Trade a client_id and client_secret for a JWT, attach it as Authorization: Bearer .... Scopes determine which endpoints are reachable.

POST /api/v3/m2m-auth
02 / Backoffice user

User JWT.

For tools that act on behalf of an Eventtia user — admin scripts, custom backoffice extensions. Authenticate with email + password (or SSO), get a JWT scoped to that user's role and permissions. Granular access via the permissions system.

POST /api/v3/authenticate
03 / Attendee

Attendee token.

For attendee-facing apps — the registered attendee browses their agenda, submits meeting requests, answers a survey, rates a session. Token scoped to the attendee's own record; sponsor delegation supported when a sponsor manages multiple attendees.

Issued via registration flow
Code samples

From auth to webhook in twenty lines.

Five common operations. Real endpoints. Cut, paste, replace the token, watch it work. The full reference includes JS/TS, Python, Ruby, and Go variants.

# 1. Authenticate as a server-side integration
curl -X POST https://connect.eventtia.com/api/v3/m2m-auth \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "$CLIENT_ID",
    "client_secret": "$CLIENT_SECRET"
  }'

# Response — JWT to use as Bearer token in every other call
{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "scope": "events:* attendees:* checkpoints:* webhooks:*",
  "expires_in": "2026-06-16T18:00:00Z",
  "token_type": "Bearer"
}
# 2. Create an event under your account
curl -X POST https://connect.eventtia.com/api/v3/events \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "type": "events",
      "attributes": {
        "name": "ICORI 2026",
        "event_uri": "icori-2026",
        "start_date": "2026-05-22T09:00:00",
        "end_date": "2026-05-22T18:00:00",
        "timezone": "America/Bogota"
      }
    }
  }'
# 3. Register an attendee, optionally with custom fields
curl -X POST https://connect.eventtia.com/api/v3/events/12345/attendees \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "data": {
      "type": "attendees",
      "attributes": {
        "email": "[email protected]",
        "first_name": "Maya",
        "last_name": "Khan",
        "attendee_type_id": 42,
        "custom_fields": {
          "company": "Atlas Research",
          "dietary_restrictions": "vegetarian"
        }
      }
    }
  }'
# 4. Subscribe to attendee_created events at the account level
# Optionally filter to specific administrative areas (regions/brands)
curl -X POST https://connect.eventtia.com/api/v3/account-webhooks \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "target_url": "https://hooks.yourcompany.com/eventtia",
    "trigger": "attendee_created",
    "administrative_area_ids": [3, 7]
  }'

# Your endpoint receives, per registration:
# { "event_id": 12345, "attendee_id": 98765, "occurred_at": "..." }
# 5. Check in an attendee at a specific checkpoint
curl -X POST https://connect.eventtia.com/api/v3/checkpoints/9/check-in \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "attendee_uuid": "8c5e2-..."
  }'

# For offline / batch:
# POST /api/v3/checkpoints/9/batch-checkin
# with an array of { attendee_uuid, checkpoint_id, action, action_at }
Webhooks

Real-time data, out of the box.

Webhooks fire the moment something happens in the platform. Subscribe at the account level (every event in the account) or per event. Account-level subscriptions can filter to specific administrative areas. The endpoint receives a JSON payload with the entity ID and occurrence timestamp; pull the full record via the REST API when you need it.

Available triggers

  • attendee_created a new registration lands
  • attendee_updated profile or status changes
  • attendee_paid payment confirmed
  • attendee_checked_in door scan succeeded
  • meeting_request_created networking request sent
  • meeting_accepted networking request approved
  • workshop_registration_created session enrollment
  • survey_answered response submitted

Full trigger list and per-trigger payload schemas in the API reference.

Two scopes

Account-level

One subscription, fires for every event in the account that matches the trigger. Optional administrative_area_ids filter restricts to specific regions, brands, or business units.

POST /api/v3/account-webhooks

Event-level

Subscription scoped to a single event. Useful for high-cardinality events or one-off integrations. Requires the event to have webhooks enabled in its settings.

POST /api/v3/events/{event_id}/event-webhooks
For AI agents

The first open MCP server for event management.

Model Context Protocol is the emerging standard for how AI agents discover and call tools. Eventtia exposes the platform as an MCP server, so Claude, ChatGPT, custom agents, and whatever comes next can operate events natively — create an event, pull registration stats, send a targeted reminder, orchestrate workflows — without bespoke integration work for every model.

01
One protocol, every agent. Agents discover the available tools the same way they discover Slack, GitHub, or any other MCP server. Your customers don't write per-model adapters.
02
Conversational, not programmatic. "Set up a 200-person workshop on June 12, invite the previous attendees of the May event, and remind anyone who hasn't responded by Thursday." The agent maps that to the right API calls.
03
Same auth, same data model. The MCP server sits on top of the REST API. Same tokens, same scopes, same permissions. What an agent can do is exactly what a human user with the same token can do.

More on the agentic approach in the blog post on agentic event software. A dedicated MCP page is in progress — coming soon.

In production

Nike runs 5,000+ events a year on Eventtia's API.

Headless infrastructure across Nike.com, the iOS app, and the Android app.

Nike's global IT department embedded Eventtia as event infrastructure across three digital surfaces. Attendees register inside Nike-branded surfaces and never see Eventtia. The registration engine, the payment flow, the check-in record, the reporting — all behind the API, all under Nike's brand. Integration completed in under 90 days. Now running 5,000+ events per year across the program.

5,000+ events per year
3 digital surfaces
< 90 days to integration go-live
Read the Nike case study →
For developers

Docs, environments, support. No mystery boxes.

Reference

Full API documentation.

Every endpoint with request/response schemas, real examples in multiple languages, in-page try-it (via ReadMe). OpenAPI spec available for client generation.

docs-connect-api-v3.eventtia.com →
LLM-ready

Indexed for AI agents.

The docs ship an llms.txt index in Markdown plus OpenAPI definitions per endpoint. Agents can discover the full surface programmatically and call endpoints with structured context.

View llms.txt →
Support

A dedicated team for enterprise integrations.

For Nike-style headless deployments and complex multi-region setups, an Eventtia integration engineer joins the project from architecture review through go-live. Not a ticketing queue.

Talk to us →
Status

Real-time platform status.

API uptime, incident history, and component-level health at status.eventtia.com. Subscribe by email or RSS for incident notifications.

status.eventtia.com →
FAQ

What integration leads always ask.

What's the API's uptime SLA?

API availability follows the same SLA as the platform itself. High Priority issues (full outage or anything blocking a live event) carry a 15-minute response and 1-hour resolution target. Live status and incident history are at status.eventtia.com; the full SLA is at the SLA page.

How is the API versioned?

URL-versioned. The current production version is /api/v3/. Breaking changes go behind a new version; the previous version stays available with documented deprecation timelines. Non-breaking additions (new endpoints, new optional fields) ship within the current version without notice.

Are there rate limits?

Yes, applied per token. The default tier handles typical integration loads comfortably; enterprise integrations (Nike-scale, 5,000+ events/year) get raised limits as part of the deployment. Rate limit responses include the standard X-RateLimit-Remaining and Retry-After headers so your retry logic has what it needs.

Where is the API hosted?

Eventtia operates legal entities in Europe with infrastructure in both the EU and the US. Same API, same features, whichever side of the Atlantic matches your compliance posture. Data residency is selected at the account level during onboarding. GDPR-aligned handling applies in both regions.

What authentication does the API use?

JWT throughout. Three token types: machine-to-machine (OAuth client credentials, for server-side integrations), user (for tools acting on behalf of an Eventtia user), and attendee (for attendee-facing apps). Tokens carry scopes and expirations; the API enforces them at the endpoint level. See the Authentication section above for the model.

Do webhooks have payload signing?

Yes. Each webhook delivery includes an HMAC signature in the request headers, computed with a shared secret. Verify the signature server-side before trusting the payload. Replay protection is provided via an occurrence timestamp + signed nonce.

Can we test against a sandbox before going live?

Yes. Enterprise integrations get a dedicated test environment with a copy of the production data model and the same API surface. Useful for CI integration tests, schema migrations, and dry-running deployment changes before they touch real events.

Is there a Postman collection or SDK?

The OpenAPI spec is published with the docs, which lets you generate clients in any language with standard tooling (openapi-generator, etc.). A Postman collection is available on request. First-party SDKs aren't shipped by default because most integration teams prefer to generate the client that matches their codebase.

How does the MCP server relate to the REST API?

The MCP server sits on top of the REST API as a translation layer. It exposes the API's operations to AI agents in the Model Context Protocol format. Auth model is the same (Bearer tokens); permissions are the same (what an agent can do is exactly what a user with that token can do via REST). More detail in the MCP section above; a dedicated page is coming.

Who owns the data accessed through the API?

You do. Eventtia is the data processor; you are the controller. The API doesn't add any data sharing or retention terms beyond what's in the main contract. Full attendee, transaction, and registration data exports via the API at any time. The legal basis is in the privacy policy.

Build with the API. Talk to a real engineer.

For Nike-scale headless deployments and complex multi-region setups, an integration engineer from Eventtia joins your team from architecture review through go-live. 30 minutes, no deck, real answers to real questions.

Read the docs → Talk to us