canonical: https://jentic.com/apis/fomo.com/fomo

# Fomo API

Jentic publishes a curated, agent-optimized OpenAPI specification for Fomo API, keeping it validated and up to date. Fomo is a social proof automation platform that displays real customer activity - recent purchases, signups, reviews - as on-site notifications. The API exposes endpoints for creating and managing events, defining notification templates, reading application statistics, and configuring application settings. Authentication uses a token in the Authorization header.

## For AI agents

Push purchase, signup, and engagement events into Fomo to trigger on-site social proof notifications, and manage templates and application settings.

## Scope

Does not handle email delivery, SMS, or transactional payments - use for Fomo on-site social proof events, templates, and application stats only.

## Capabilities

- Create social proof events such as purchases or signups via `/applications/me/events`
- List, retrieve, update, and delete existing events by ID
- Define and manage notification templates that style how events appear
- Read application-level statistics for engagement reporting
- Inspect or update settings on the connected Fomo application
- Backfill historical events for new on-site notification campaigns

## Use cases

### On-Site Social Proof from Purchases

Forward order events from your store to Fomo via POST `/applications/me/events` so the platform displays a real-time 'someone in Berlin just bought X' notification on your site. Suits e-commerce teams that want to lift conversion through trust signals without building their own notification infrastructure. Setup typically takes a couple of hours including event mapping.

Example prompt: Create a Fomo event via POST `/applications/me/events` with type 'order' and a payload describing a purchase of $49 by a customer in 'Berlin, DE'.

### Template Management for Brand Consistency

Manage notification templates through `/applications/me/templates` so the social proof popups match your brand voice and visual style. Useful when running multi-language stores or different campaigns per product line. Templates can be created, listed, and applied to specific event types.

Example prompt: List templates via GET `/applications/me/templates` and return the IDs and names of templates whose name contains 'order'.

### Application Statistics Reporting

Pull engagement metrics for your Fomo application through GET `/applications/me/statistics` to feed dashboards and weekly reports. The endpoint surfaces aggregate counts that quantify how social proof is performing without the team logging into the Fomo dashboard. Combine with your analytics warehouse for end-to-end attribution.

Example prompt: Call GET `/applications/me/statistics` and return the top-line engagement counters for the connected Fomo application.

### AI Agent Social Proof Integration via Jentic

Agents use Jentic's intent search to find Fomo operations, load the schema for the events endpoint, and execute calls under a scoped credential. This is the recommended path for assistants that pipe order or signup events from a CRM or ecom backend into Fomo without exposing the raw token. Jentic keeps credentials isolated.

Example prompt: Use Jentic to search 'create a Fomo event', load the POST `/applications/me/events` schema, and create an event for a recent order with the values supplied by the user.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/applications/me/events` | List events for the connected application |
| POST | `/applications/me/events` | Create a new social proof event |
| GET | `/applications/me/events/{id}` | Retrieve an event by ID |
| PATCH | `/applications/me/events/{id}` | Update an event |
| DELETE | `/applications/me/events/{id}` | Delete an event |
| GET | `/applications/me/templates` | List notification templates |
| GET | `/applications/me/statistics` | Read application engagement statistics |
| GET | `/applications/me` | Read application settings |

## Key resources

- **Events** — Create, retrieve, update, and delete social proof events.
- **Templates** — Manage notification templates that style how events render on-site.
- **Application** — Inspect or update settings on the connected Fomo application.
- **Statistics** — Read aggregate engagement metrics for the application.

## Why Jentic

- **Setup:** Wiring the Fomo API by hand means setting its Authorization token on every request and building your own retry and error handling around the on-site event endpoints. Through Jentic you install once, import Fomo from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Fomo puts the event id in the URL path (`/applications/me/events/{id}`), so a rule can pin your agent to reading and creating events: you choose the operations it may call, so destructive ones like deleting or patching an event are not included unless you add them. Every operation the agent can run is one you chose.
- **Credential handling:** Your Fomo token 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 'create a Fomo event', and Jentic returns the POST `/applications/me/events` operation with its input schema so the agent posts the right event type without browsing the reference docs.

## Related APIs

- **Klaviyo API** — Email and SMS marketing platform that pairs with Fomo's on-site social proof.
- **Customer.io API** — Event-driven messaging that consumes the same customer activity stream as Fomo.
- **Mailchimp API** — Email marketing platform for follow-ups to the visitors Fomo notifications convert.

## FAQ

### Does Fomo publish an official OpenAPI specification?

Fomo's reference docs run on ReadMe, and the platform exposes a machine-readable OpenAPI document for the API at https://dash.readme.com/api/v1/api-registry/8hz4kq6sa77k. That document is emitted by the documentation platform rather than published by Fomo as a spec, and it is not usable as-is: it declares no security schemes, its server URL still carries an unresolved version placeholder, and its paths are written with Rails-style :ID segments rather than OpenAPI parameter templates. Jentic therefore keeps this curated, agent-optimized specification, validated against the live API, instead of silently substituting that document. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Fomo API use?

The Fomo API uses a token issued from the Fomo dashboard, passed in the Authorization header. Jentic stores the token encrypted in your Jentic One instance and injects it on outbound calls so the agent never holds the raw secret.

### Can I create custom event types with the Fomo API?

Yes, POST `/applications/me/events` accepts arbitrary event payloads that you can map to templates defined in `/applications/me/templates.` This is how you display custom on-site notifications such as signups, downloads, or reviews.

### What are the rate limits for the Fomo API?

The OpenAPI spec does not declare explicit rate limits. Apply client-side throttling for bulk backfills and back off on 429 responses returned by the service.

### How do I push order events from my store through Jentic?

Search Jentic for 'create a Fomo event', load the POST `/applications/me/events` schema, and execute with the order details. Jentic handles auth and request shaping so the agent only supplies the order fields.

### Can the Fomo API delete or update existing events?

Yes, `/applications/me/events/{id}` supports retrieval, update, and deletion of an event by its ID. Use this to correct test events or remove events that should not appear as social proof.

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

Yes. Because you run Jentic One yourself, your own rules decide which Fomo operations the agent may call and which stored credential it uses. You can allow it to list and create events at `/applications/me/events` and read templates or statistics, while withholding the destructive operations on `/applications/me/events/{id}` such as PATCH and DELETE unless you explicitly add them. Every operation the agent can run is one you chose.