Install Jentic One Beta

Connect the Keep'em API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Keep'em API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fkeepem.io%2Fkeepem" | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fkeepem.io%2Fkeepem" | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with Keep'em API.

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

GET STARTED

Start building with Keep'em API

Explore with Jentic One

View OpenAPI Document

Use Cases

Patterns agents use Keep'em API for, with concrete tasks.

★ 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.

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.

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.

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

2 endpoints — the keep'em api is a small, focused rest api for connecting external systems to keep'em's event registration and viewer-identification platform.

METHOD

PATH

DESCRIPTION

POST

/events/{eventID}/register

POST

/events/{eventID}/identify

Identify an existing viewer attending an event

POST

/events/{eventID}/register

POST

/events/{eventID}/identify

Identify an existing viewer attending an event

Why Jentic?

What agents get from Jentic-routed access to this vendor.

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 isolation

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.

Intent-based discovery

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.

FAQs

Specific to using Keep'em API through Jentic.

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.

Keep'em API

Name: Keep'em API
Brand: Keep'em API
Availability: InStock

Official vendor OpenAPI document · agent-readyMarketingMarketing AutomationapiKey2 EndpointsREST

For 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.

Use for: I want to register a viewer for a Keep'em event, Identify an existing viewer attending a Keep'em event, Send a registration payload for event ID abc123 to Keep'em, Confirm a returning viewer for a live Keep'em session

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

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.

Jentic One on Github View OpenAPI Document

Connect the Keep'em API to your agent

Capabilities

Start building with Keep'em API

Use Cases

Key Endpoints

Why Jentic?

Related APIs

FAQs

Keep'em API