MCP Integration

Connect your AI coding assistant to waitset. Create and manage waitlists without leaving your editor.

TL;DR

Add the waitset MCP server to your editor config, set your API key, and ask your agent "Create a waitlist on waitset." Your agent can pick a template, fill the page content, set a subdomain, and publish — all from chat.

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external tools and services. Instead of copy-pasting IDs and calling REST APIs, your agent discovers available tools automatically and calls them in natural language.

waitset exposes an MCP server so agents like Cursor, Claude Code, and Windsurf can create waitlists, list projects, and manage signups directly.

Quick start

Get your API key

Go to your API keys page and generate a key.

Add the MCP config

Create or edit .mcp.json in your project root:

.mcp.json

{
  "mcpServers": {
    "waitset": {
      "type": "http",
      "url": "https://waitset.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${WAITSET_API_KEY}"
      }
    }
  }
}

Set WAITSET_API_KEY in your .env (never commit the key).

Install in your tool

Claude Code

claude mcp add --transport http secure-api https://waitset.com/api/mcp --header "Authorization: Bearer ${WAITSET_API_KEY}"

Uses your WAITSET_API_KEY env var (recommended). Don’t paste keys into chat logs.

Cursor (recommended)

Add a .mcp.json file to your project root:

{
  "mcpServers": {
    "waitset": {
      "type": "http",
      "url": "https://waitset.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${WAITSET_API_KEY}"
      }
    }
  }
}

Then set WAITSET_API_KEY in your .env.

Ask your agent

> "Create a waitlist called Early Access on waitset"

✓ Waitlist created

✓ Hosted page prepared

→ Complete setup at waitset.com/project/onboarding/...

The agent calls create_waitlist which creates your waitlist and prepares a hosted page. Then your agent can call list_templates, update_page_template, update_page_domain, and publish_page to finish everything without leaving chat.

After publishing, agents should use the smokeTest result returned by create_waitlist to confirm the page loads (and detect common error screens).

How it works

Authenticate

Your API key is sent as a Bearer token with every request.

Discover tools

Your agent auto-discovers all available waitset tools via the MCP protocol.

Execute

The agent calls the right tool with the right args. You get results in your chat.

Available tools

These are the tools your agent can call. The primary one is create_waitlist — it mirrors our onboarding and handles everything in a single call.

create_waitlistRecommended

Creates a new waitlist and prepares a hosted signup page — like running onboarding in chat. Returns a `smokeTest` result when published so agents can immediately verify the page loads.

Arguments

namestring— Name for your waitlist (2-64 chars)

templateKeystringoptional— Page template key, e.g. "minimal-hero@0.0.1". Recommended: call list_templates first and pick based on description + data schema.

Returns

projectId, waitlistId, pageId, onboardingPath

list_templates

List templates with description, tags, and a `dataSchema` summary (required/optional + types) so agents can build correct `data` without guessing.

Returns

Array of { key, name, version, humanReadableName, description, tags, latestVersion }

update_page_template

Set a template and content payload for the hosted signup page (used to fill copy, sections, images, etc.).

Arguments

pageIdstring— The page ID returned by create_waitlist

templateKeystring— Template key like "minimal-hero@0.0.1"

dataobject— Template data payload (JSON object)

Returns

{ ok: true }

update_page_domain

Set the waitset subdomain (and optionally custom domain) for your hosted signup page.

Arguments

pageIdstring— The page ID to update

subdomainstring— Subdomain, e.g. "my-app"

domainstringoptional— Optional custom domain

Returns

{ ok: true, pageUrl }

publish_page

Publish (enable) or unpublish the hosted signup page.

Arguments

pageIdstring— The page ID to publish

enabledboolean— true to publish

Returns

{ ok: true }

list_projects

List all projects owned by the authenticated user.

Returns

Array of { _id, name, createdAt }

create_project

Create a standalone project container (advanced — normally you just use create_waitlist).

Arguments

namestring— Project name

Returns

projectId

create_additional_waitlist

Create an additional waitlist inside an existing project. Only needed when you already have a project and want multiple waitlists.

Arguments

projectIdstring— The project ID

namestring— Waitlist name (2-64 chars)

Returns

waitlistId

list_waitlists

List all waitlists in a project.

Arguments

projectIdstring— The project ID

Returns

Array of { _id, name, createdAt }

get_waitlist

Get waitlist details including the public signup URL.

Arguments

waitlistIdstring— The waitlist ID

Returns

{ _id, name, projectId, isPublic, createdAt, pageUrl }

set_waitlist_public

Show or hide a waitlist from the public gallery.

Arguments

waitlistIdstring— The waitlist ID

isPublicboolean— true to feature publicly

Returns

{ ok: true }

Supported clients

Any tool that speaks the MCP protocol works. Here are the ones we test with:

Cursor

Add .mcp.json to your project root. Cursor discovers it automatically.

Claude Code

Use the /mcp command or add the server to your claude_desktop_config.json.

Windsurf

Add the MCP server in Windsurf settings under AI > MCP Servers.

Custom clients

POST to https://waitset.com/api/mcp with Bearer auth. Standard MCP Streamable HTTP transport.

Example prompts

Try these in your AI assistant after setting up the MCP server:

>"Create a waitlist called "Beta Testers" on waitset"

>"List all my waitset projects"

>"Show me the waitlists in my latest project"

>"Get the signup URL for my waitlist"

>"Make my waitlist public on the gallery"

Ready to try it?

Generate an API key, drop the config into your project, and let your agent build your next waitlist.

Get started Questions? Email us