# Enlist

> Waitlist infrastructure as an API. You own the UI; Enlist owns the list, the positions, the emails, and the analytics.

Enlist is an API-first SaaS platform for managing product launch waitlists. It handles position assignment inside a locked Postgres transaction, sends signup emails with delivery tracking, and exposes the same operations over REST, a TypeScript SDK, and an MCP server for AI coding agents.

## Key facts

- Every signup returns its queue position and total in the same response — no polling, no second request.
- Positions are assigned server-side and never recomputed. They are stable for the life of the waitlist.
- Signup emails are sent via the account's configured email provider. Delivery, open, and click events are written back onto the signup row.
- Re-submitting the same email is a no-op: the original position is returned and no duplicate email is sent.
- Every signup is issued a permanent `referral_code`. Passing someone else's code on a later signup increments their `referral_count` and stamps `referred_by`; positions are never affected, so what a referral is worth is the caller's decision.
- A waitlist can declare typed custom fields (`string`, `number`, `boolean`, each optional or required, at most 20 per waitlist). Values are validated at signup, rejected on a type mismatch, and available as `{{key}}` placeholders in the signup email. Unknown keys are stripped rather than stored.
- Separately, `metadata` is an opaque store of up to 10 string key/value pairs for the developer's own data. It is never a template variable, and it is stamped once at creation — a re-signup does not update it. Both metadata values and custom string field values cap at 1000 characters.
- The REST API is CORS-enabled, but the bearer key must never ship to the browser. Always proxy through a server route on your own backend — see the integration guides below.
- Free plan: 500 signups per account across all waitlists.

## Pricing

Nothing is metered. Past a plan limit the answer is upgrade, never a surprise invoice. The signup limit is capacity, not throughput: deleting a signup frees its space. Annual billing is 2 months free.

- **Free** (Free): 500 stored signups, 1 waitlist, 60 requests/minute, bring your own Resend key.
- **Launch** ($15/month): unlimited stored signups, 5 waitlists, 300 requests/minute, 5,000 managed emails/month, webhooks.
- **Scale** ($39/month): unlimited stored signups, unlimited waitlists, 1,000 requests/minute, 25,000 managed emails/month, webhooks.

Full breakdown: [Pricing](https://enlist.dev/pricing) and [Pricing & limits](https://enlist.dev/docs/pricing-tiers).

## Integration options

Three ways to integrate — same operations, same API key, same response shape:

1. **REST**: plain `fetch()` to `https://api.enlist.dev/v1/…`, no client library required.
2. **TypeScript SDK**: `npm install @enlistdev/sdk` — typed wrapper, identical to the REST API.
3. **MCP server**: `npx @enlistdev/mcp` or `https://api.enlist.dev/mcp` — lets Claude Code, Cursor, or any MCP-capable agent create waitlists and add signups directly.

## Documentation

- [Quickstart](https://enlist.dev/docs): Get an API key, install the SDK, and add the first signup in five lines of TypeScript.
- [API reference](https://enlist.dev/docs/api): Full REST endpoint reference — create waitlists, add signups, paginate signups, read stats.
- [TypeScript SDK](https://enlist.dev/docs/sdk): `@enlistdev/sdk` usage with all methods and response types.
- [MCP server](https://enlist.dev/docs/mcp): Wire Enlist into Claude Code, Cursor, or Claude Desktop with one command.
- [OpenAPI 3.1 spec](https://enlist.dev/api/openapi.json): Machine-readable description of every endpoint, request body, response shape, and error code. Prefer this over prose when generating client code.

## API base URL

`https://api.enlist.dev`

All endpoints take an `Authorization: Bearer en_live_…` header. Bodies and responses are JSON.

## Key endpoints

```
GET    /v1/account                          Plan and live quota usage
POST   /v1/waitlists                        Create a waitlist
GET    /v1/waitlists                        List waitlists with signup counts
POST   /v1/waitlists/:id/signups            Add a signup, returns { id, position, total, referral_code }
GET    /v1/waitlists/:id/signups            Paginate signups (limit, offset, email filter)
GET    /v1/waitlists/:id/signups/export     The whole list as streamed CSV
DELETE /v1/waitlists/:id/signups/:signupId  Remove a signup; nobody else's position moves
GET    /v1/waitlists/:id/stats              Aggregate stats and utm_source breakdown
```

## Security: keep the API key server-side

**Never call the Enlist API directly from browser JavaScript.** An API key in client-side code is readable by anyone. Always proxy through a server route on your own backend — the integration guides below all show this pattern. The quick example below is a server-side handler, not a browser snippet.

## Quick example

```ts
// Server-side only — Next.js route handler, SvelteKit endpoint, etc.
import { Enlist } from '@enlistdev/sdk';

const enlist = new Enlist({ apiKey: process.env.ENLIST_API_KEY });
const signup = await enlist.waitlists.addSignup(waitlistId, { email: 'ada@example.com' });
// signup.position → 47
// signup.total    → 1203
```

## Integration guides

- [Next.js](https://enlist.dev/for/nextjs): Route handler + form component. API key stays server-side.
- [SvelteKit](https://enlist.dev/for/sveltekit): +server.ts endpoint with $env/static/private.
- [Remix](https://enlist.dev/for/remix): Action function + useFetcher form.
- [Astro](https://enlist.dev/for/astro): APIRoute endpoint.
- [Nuxt](https://enlist.dev/for/nuxt): server/api route via defineEventHandler.

## Integrations

Every real way Enlist connects to your stack — index at [https://enlist.dev/integrations](https://enlist.dev/integrations).

- [REST API](https://enlist.dev/integrations/api): A plain JSON API over HTTPS. No client library required — every operation is one request, and the response is the same shape the SDK and MCP server return.
- [TypeScript SDK](https://enlist.dev/integrations/sdk): @enlistdev/sdk wraps the REST API in typed methods — same operations, same response shapes, autocomplete on every field.
- [MCP server](https://enlist.dev/integrations/mcp): Connect once and Claude Code, Cursor, or any MCP-capable agent can create waitlists and add signups directly — no route handler to write by hand.
- [Webhooks](https://enlist.dev/integrations/webhooks): Enlist POSTs a signed JSON body to your endpoint for five event types — new signups, removals, and signup-email delivered/opened/clicked.
- [Email provider](https://enlist.dev/integrations/email): Enlist-managed sending needs zero configuration. Or connect your own Resend key and send on your own domain — Enlist still tracks delivery, opens, and clicks either way.

## Use cases

The scenarios Enlist is built for — index at [https://enlist.dev/use-cases](https://enlist.dev/use-cases).

- [Staged and beta rollouts](https://enlist.dev/use-cases/staged-rollout): You're inviting people in batches and access depends on order — a beta, a limited launch, an invite wave.
- [Agent-wired, vibe-coded launches](https://enlist.dev/use-cases/agent-wired): You're building fast with Claude Code, Cursor, or another coding agent and don't want to hand-write a waitlist backend to ship a landing page.
- [A public feature-request queue](https://enlist.dev/use-cases/feature-queue): You want a public prioritization signal for what to build next, without building a voting feature yourself.
- [A launch that might actually spike](https://enlist.dev/use-cases/spike-proof-pricing): You're a solo founder or small team and your signup count could jump overnight — a front-page Hacker News or Product Hunt day.

## Roadmap

What Enlist does not do yet. Anyone can vote for a feature with their email at [https://enlist.dev/roadmap](https://enlist.dev/roadmap), and the vote counts on that page are live.

- **Slack integration** (Considering): A message in your Slack channel every time someone joins, so a launch shows up where your team already is.
- **Discord integration** (Considering): A message in your Discord channel every time someone joins, so your community can watch the list grow.
- **Waitlist tags and filtering** (Considering): Give a waitlist any number of tags, then ask for one tag instead of every waitlist you have. Useful once one account is running more than a handful.
- **Team members** (Considering): More than one login on an account, with roles that scope what each person can do. A teammate could read signups without holding a key that can delete them.
- **Broadcasts and announcements** (Planned): Send one message to everyone on a waitlist, for a launch announcement or a beta invite. Today the only mail we send is the signup email, one signup at a time.

## Other pages

- [Tools](https://enlist.dev/tools): Free, no-signup developer tools — JWT decoder, JSON formatter, Base64 encoder/decoder, UUID generator, Regex tester, Text diff, Cron expression parser, UTM builder, Open Graph preview, llms.txt generator, Launch checklist.
- [JWT decoder](https://enlist.dev/tools/jwt): Decode a JSON Web Token and inspect the header and payload. Client-side only.
- [JSON formatter](https://enlist.dev/tools/json): Validate and pretty-print JSON. Errors shown inline.
- [Base64 encoder/decoder](https://enlist.dev/tools/base64): Encode or decode Base64. Unicode-safe.
- [UUID generator](https://enlist.dev/tools/uuid): Generate cryptographically random v4 UUIDs.
- [Regex tester](https://enlist.dev/tools/regex): Test JavaScript regular expressions with live match highlighting.
- [Text diff](https://enlist.dev/tools/diff): Line-level diff of two text blocks.
- [Cron expression parser](https://enlist.dev/tools/cron): Plain-English description of a cron schedule.
- [UTM builder](https://enlist.dev/tools/utm): Build UTM-tagged campaign URLs.
- [Open Graph preview](https://enlist.dev/tools/og-preview): Preview how a URL unfurls on X, LinkedIn, and Slack.
- [llms.txt generator](https://enlist.dev/tools/llms-txt): Generate an llms.txt file for your site.
- [Launch checklist](https://enlist.dev/tools/launch-checklist): Interactive pre-launch checklist with progress tracking.
- [Pricing](https://enlist.dev/pricing): Plan comparison and the annual discount.
- [Changelog](https://enlist.dev/changelog): What shipped, newest first.
- [Blog](https://enlist.dev/blog): Comparisons and writing on waitlist infrastructure.
- [Comparisons](https://enlist.dev/vs): How Enlist compares to the waitlist tools, form builders, and email platforms developers evaluate.

## Comparisons

How Enlist differs from each alternative — index at [https://enlist.dev/vs](https://enlist.dev/vs).

- [Enlist vs Prefinery](https://enlist.dev/vs/prefinery): Prefinery is the incumbent developer-first waitlist platform — mature API, webhooks, A/B testing, referrals — but the API is gated behind a $199/mo plan.
- [Enlist vs MakeEmWait](https://enlist.dev/vs/makeemwait): MakeEmWait is the cheapest dedicated waitlist API — unlimited waitlists and signups from a low monthly price — but ships no managed email, no delivery tracking, and no SDK.
- [Enlist vs Loops](https://enlist.dev/vs/loops): Loops is developer-first email infrastructure — full REST API, official SDKs, transactional and marketing email — but has no queue mechanic, no position tracking, and no referral system.
- [Enlist vs GetWaitlist](https://enlist.dev/vs/getwaitlist): GetWaitlist is the most established dedicated waitlist platform — strong viral mechanics, a real API, and deep third-party integrations — but removed its free tier for new accounts in June 2025.
- [Enlist vs Waitlister](https://enlist.dev/vs/waitlister): Waitlister is an all-in-one platform with a landing page builder, referral system, and welcome email — but developer API access starts at the fourth paid tier.
- [Enlist vs LaunchList](https://enlist.dev/vs/launchlist): LaunchList offers lifetime pricing with referral mechanics on the free tier, but has no native REST API — the programmatic surface is webhooks only, at the second paid tier.
- [Enlist vs Viral Loops](https://enlist.dev/vs/viral-loops): Viral Loops is the strongest referral campaign platform in this market, built around proven viral mechanics — but the API requires the Plus plan, and billing scales per participant.
- [Enlist vs KickoffLabs](https://enlist.dev/vs/kickofflabs): KickoffLabs specializes in gamified launch campaigns — contests, sweepstakes, referrals with rewards — but has no documented REST API and bills by leads per month.
- [Enlist vs Tally](https://enlist.dev/vs/tally): Tally has the most generous free tier of any tool in this market — unlimited forms and submissions with no credit card — but is a form builder with no queue mechanic or position tracking.
- [Enlist vs Typeform](https://enlist.dev/vs/typeform): Typeform has the best form UX in this market — polished, conversational signups with a real API — but bills by responses per month, which punishes a successful launch.
- [Enlist vs Mailchimp](https://enlist.dev/vs/mailchimp): Mailchimp is full-featured email marketing used as a bare-bones waitlist via a contact list form — but has no queue mechanic, no position tracking, and a 250-contact free tier.

## Full content

- [Complete documentation](https://enlist.dev/llms-full.txt): All docs pages and marketing copy in one Markdown file.

## Company

Enlist — https://enlist.dev