canonical: https://jentic.com/apis/keepem.io/keepem

# Keep'em API

The Keep'em API is a small, focused REST API for connecting external systems to Keep'em's event registration and viewer-identification platform. It exposes two POST operations under `/events/{eventID}`: one to register a viewer for an event and one to identify a viewer who is already attending. Authentication uses an X-API-Key header. The API is designed to be embedded in event funnels - landing pages, registration forms, and live broadcast tooling - where a third-party system needs to push attendee data into Keep'em or confirm a returning viewer's identity.

## For AI agents

Register attendees and identify returning viewers for Keep'em events through two POST endpoints scoped by event ID, authenticated with an X-API-Key header.

## Scope

Does not handle event creation, agenda management, ticketing, or attendee export - use for pushing viewer registrations and identifications into Keep'em only.

## Capabilities

- Register a new viewer for a specific Keep'em event by event ID
- Identify a returning viewer against an existing Keep'em event session
- Pass viewer attribute payloads through the registration endpoint for downstream segmentation in Keep'em
- Authenticate every request with the X-API-Key header so registration traffic is tied to a single Keep'em workspace
- Embed event registration into a third-party landing page without hosting Keep'em's own form

## Use cases

### Custom Landing Page Registration

Capture attendee registrations from a branded landing page and push them into Keep'em without using the platform's hosted form. The registration endpoint accepts the event ID in the path and the viewer payload in the body, so a marketing site can submit form data directly. Authentication is a single X-API-Key header, so integration takes under an hour.

Example prompt: Submit POST `/events/{eventID}/register` with the eventID and the viewer's email and name fields to register them for an upcoming event

### Returning Viewer Identification

When a known viewer revisits a Keep'em event - for example clicking a personalised email link to a live broadcast - the identify endpoint links the session to their existing Keep'em viewer record. This avoids creating duplicate viewer rows and keeps engagement data attached to one identity. The flow is a single POST `/events/{eventID}/identify` call from the embedded player or follow-up page.

Example prompt: Call POST `/events/{eventID}/identify` with the eventID and the viewer's email to attach the current session to their existing Keep'em record

### AI Agent Registration Workflow

An AI agent that handles inbound event signups discovers the Keep'em registration operation through Jentic, loads its schema, and submits the registration payload on behalf of the user. Because the API only has two operations, the agent does not need to disambiguate - Jentic returns the right endpoint by intent. The X-API-Key is held in Jentic's vault and injected at execution time.

Example prompt: Use Jentic to find and execute POST `/events/{eventID}/register` with the user's name, email, and the eventID extracted from the conversation

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/events/{eventID}/register` | Register a viewer for an event |
| POST | `/events/{eventID}/identify` | Identify an existing viewer attending an event |

## Key resources

- **Events** — Register and identify viewers against a specific Keep'em event by event ID

## Why Jentic

- **Setup:** Wiring the Keep'em API by hand means learning its X-API-Key header, calling api.keepem.io/v1, and mapping the register and identify payloads to their shapes yourself. Through Jentic you install once, import the Keep'em API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Keep'em puts the event id in the URL path (`/events/{eventID}/register`), so a rule can pin your agent to one event: it can register and identify viewers for that event and nothing else. You choose the operations it may call, so it stays on registration unless you add identification.
- **Credential handling:** Your Keep'em X-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 'register a viewer for an event', and Jentic returns the matching Keep'em operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Meetup** — Meetup hosts and registers attendees for community events with built-in discovery and RSVP flows.
- **Cvent** — Cvent is an enterprise events platform covering registration, agendas, and on-site logistics.
- **Mailchimp** — Mailchimp delivers the email invitations and reminders that drive registrations into Keep'em.

## FAQ

### What authentication does the Keep'em API use?

Every request must include the X-API-Key header. The key is issued from your Keep'em workspace and identifies the workspace that owns the event. Through Jentic, the X-API-Key is stored encrypted and injected per call so an agent never reads it directly.

### Can I register a viewer for an event with the Keep'em API?

Yes. POST `/events/{eventID}/register` with the eventID in the path and the viewer payload in the body. The endpoint creates the viewer registration in Keep'em and returns confirmation; reuse the same eventID across many registration calls for one event.

### What are the rate limits for the Keep'em API?

The OpenAPI spec does not publish a rate limit. With only two endpoints, throughput is generally bound by Keep'em's per-event ingestion plan rather than per-second limits. If you receive HTTP 429, back off exponentially and retry the registration call.

### How do I identify a returning viewer through Jentic?

Search Jentic for 'identify a viewer for a keepem event' to find the POST `/events/{eventID}/identify` operation, load its schema, and execute it with the eventID and viewer identifier. The standard flow is pip install jentic, then client.search, client.load, and client.execute.

### Can the Keep'em API list all registered attendees?

No. The public API exposes only two write operations - register and identify - and does not provide a list or read endpoint. To export attendees, use the Keep'em dashboard or any export tooling Keep'em provides outside this API surface.

### Can I limit what my agent is allowed to do with the Keep'em API?

Yes. Because you run Jentic One yourself, your own rules decide which of the two Keep'em operations the agent may call, so you can let it register viewers with POST `/events/{eventID}/register` while withholding POST `/events/{eventID}/identify`, or the reverse. Since the event id sits in the URL path, a rule can also pin the agent to a single event so it can register and identify viewers only for that event and nothing else. Your X-API-Key is held by your own instance and injected at execution time, so the agent never reads the credential directly.