Connect Claude to Your Waitlist: Managing Your Queue with an AI Assistant via MCP

What Is MCP and Why Does It Matter for a Waitlist

The Model Context Protocol (MCP) is an open standard that lets AI assistants like Claude safely read from and write to external systems — your waitlist, your calendar, your CRM — through a small, well-defined set of tools. Instead of copy-pasting customer details between apps or training staff on a new admin UI, you describe what you want in plain English and the assistant executes it.

Waitlist App Premium ships an MCP server at https://waitlistapp.org/mcp. Once connected, Claude can list your active queue, add walk-ins, send SMS alerts through your Twilio integration, mark parties seated, and more. This guide walks through setup end-to-end.

Prerequisites

• A Premium subscription to Waitlist App. The MCP endpoint is gated on an active Premium plan — the free version does not support server-side automation.
• An API token generated from Settings → API Tokens in your Pro dashboard. Tokens are shown once; copy it immediately to a password manager.
• Optional but recommended: a configured Twilio integration (Settings → Integrations) if you want the assistant to send SMS alerts on your behalf.
• Either Claude Desktop (macOS or Windows) for interactive use, or access to the Anthropic API if you are scripting programmatic workflows.

Step 1: Generate an API Token

Log in to your Pro dashboard and open the Settings panel. Click the API Tokens tab, give the token a descriptive name (for example Claude Desktop — Front Desk iPad), and click Create Token.

The token appears once, in an amber warning banner. It looks like wla_ followed by 40 random characters. Copy it now. You cannot view it again — if you lose it you simply revoke the old one and create a new one. Tokens never expire on their own but you can revoke any token from the same screen at any time.

Step 2: Configure Twilio (Optional but Recommended)

If you want the assistant to text customers, first connect Twilio under Settings → Integrations. Paste in your Twilio Account SID, Auth Token, and either a From Number (E.164 format, like +14155552671) or a Messaging Service SID. We verify the credentials against Twilio's API before saving, so an invalid SID will be caught immediately.

Then open the SMS Alerts tab to customize which events auto-send SMS and what the message body looks like. Templates support placeholders like {{'{{ name }}'}}, {{'{{ business_name }}'}}, {{'{{ tracking_url }}'}}, {{'{{ position }}'}}, and {{'{{ party_size }}'}}. You can leave auto-triggers off and have Claude send messages manually with the notify_entry tool, or turn them on and let SMS fire automatically the instant a party is added, notified, or seated — even when the trigger came from Claude.

Step 3: Connect Claude Desktop

Claude Desktop reads MCP servers from a JSON config file. On macOS the path is ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows it is %APPDATA%\Claude\claude_desktop_config.json.

Open the file (create it if it doesn't exist) and add a mcpServers entry. The Waitlist App MCP server speaks the streamable HTTP transport with Bearer authentication:

{
  "mcpServers": {
    "waitlist": {
      "transport": "streamable_http",
      "url": "https://waitlistapp.org/mcp",
      "headers": {
        "Authorization": "Bearer wla_YOUR_TOKEN_HERE"
      }
    }
  }
}

Save the file and restart Claude Desktop. Open a new chat and type something like "What's on the waitlist right now?" — Claude should list the available waitlist tools and call list_queue. The first time a tool runs you'll be asked to approve it; check the “always allow” box if you trust the action.

Available Tools

Every tool operates only on the authenticated user's queue — the token identifies the Premium account, and ownership is enforced on every call.

Example Conversations

Once connected, you manage your queue conversationally:

You: A walk-in just came in — Maria, party of 4, phone +14155552671, wants a quiet booth.

Claude: (calls add_entry) Added Maria (4) at position 3. I didn't send a text yet since auto_on_added is off in your prefs. Want me to text her the tracking link?

You: Yes, notify her.

Claude: (calls notify_entry with event: added) Sent. SID: SM1a2b3c4d5e...

You: The 6:30 reservation is here — mark them seated.

Claude: (calls list_queue, finds the match, calls mark_seated) Done. Recalculated average service time is 18.4 minutes.

Using the Anthropic API Instead of Desktop

If you are building an internal tool or an agent that manages the waitlist programmatically, you can connect the same MCP server directly from the Anthropic Messages API using the mcp_servers parameter. Point it at https://waitlistapp.org/mcp with the same Bearer token and Claude will have full access to the tool set during the conversation.

When the API Approach Makes More Sense

Claude Desktop is ideal for conversational, on-demand management — you open it, ask a question, and act on the answer. The Anthropic API is the right choice when you need the AI layer to run automatically, on a schedule, or as part of a larger software system. Common scenarios include:

• Scheduled digests: A nightly job queries your waitlist for new sign-ups and stalled applicants, then posts a formatted summary to a Slack channel or internal dashboard.
• Event-driven workflows: When your CRM records a deal as "closed-won," an API call prompts Claude to approve the corresponding waitlist entry and trigger the welcome notification automatically.
• Internal admin panels: A back-office web application lets support staff type plain-English commands — "move Acme Corp to position 1" — without ever exposing raw API endpoints directly to the UI.
• Bulk operations with audit trails: Processing a large import or a promotional cohort approval through Claude means every action is logged as a structured conversation turn, giving you a readable record of what was done and why.

Structuring Your API Request

The core pattern is straightforward. Your request body includes the mcp_servers array alongside your normal messages array. Each entry in mcp_servers specifies the server URL and passes your Bearer token as an authorization header. Claude then decides which MCP tools to call based on the user or system message you provide, executes them server-side, and returns its reasoning along with the results in a single response.

A practical tip: write a detailed system prompt that describes the operator context. For example, tell Claude it is managing the waitlist for a B2B SaaS product, that priority should be given to enterprise-tier applicants, and that it should always confirm destructive actions like deletions before executing them. A well-crafted system prompt turns a generic AI into a domain-aware operator that behaves consistently across every automated run.

Agentic Loops and Multi-Step Tasks

The API approach also unlocks agentic patterns where Claude takes several sequential actions without a human in the loop for each step. For instance, you might ask Claude to "review all applicants who have been waiting more than 30 days, approve anyone who has a verified business email, and send me a list of those who still need manual review." Claude will call the list tool, filter the results, call the approve tool for qualifying entries, and compile the exceptions — all within a single conversation turn or a short loop of turns.

Keep multi-step agentic tasks focused and bounded. Give Claude a clear stopping condition and instruct it to surface ambiguous cases rather than making judgment calls silently. This keeps the automation useful without making it unpredictable.

Keeping Credentials Safe in a Server Environment

Unlike the Desktop configuration file that lives on a personal laptop, API integrations typically run on servers or in CI pipelines where secrets management matters even more. Store your Bearer token in your platform's secret store — environment variables injected at runtime, a dedicated secrets manager, or an encrypted vault — rather than hardcoding it in source code. Rotate the token if you suspect it has been exposed, and consider creating a dedicated API token for each automated integration so you can revoke one without disrupting the others.

Security Model

• Tokens are hashed at rest. We store SHA-256 of the token, not the plaintext. Even a database leak cannot expose your active tokens.
• Tokens are Pro-gated. When a Premium subscription lapses, all existing tokens stop working until the account is reactivated.
• Revocation is immediate. Clicking Revoke in the dashboard invalidates the token on the very next request — no cached state, no delay.
• Twilio credentials are encrypted. Account SID, auth token, and sender configuration are stored with Laravel's encrypted cast, never logged, and never returned to the client in plaintext (the auth token is masked in the UI).
• No outbound data outside MCP. The MCP endpoint only reads and writes your waitlist and optionally calls Twilio's SMS API with your credentials. We never forward your queue data to any third party.

Troubleshooting

“Unauthorized” on every call: The token is missing, malformed, revoked, or your Premium subscription has lapsed. Open Settings → API Tokens to verify the token is present and unrevoked, and check Settings → Billing for your subscription status.

SMS sends return twilio_not_configured: Visit Settings → Integrations and complete the Twilio connection.

SMS sends return sms_disabled_in_prefs: Open Settings → SMS Alerts and toggle the master switch on.

SMS sends return entry_has_no_phone: The waitlist entry was created without a phone number. Use update_entry to add one, then retry.

Tool calls hang or time out: Check your Pro dashboard's Twilio test-SMS feature first to confirm credentials still work. Twilio's own status page is at status.twilio.com.

What's Next

The current tool set covers everyday queue operations. If there is something you'd like to drive from Claude that isn't exposed yet — printing chits, running reports, editing notification templates in-session — let us know. MCP is a moving target in the industry and we plan to expand coverage as Pro usage grows.

Planned Tool Expansions

Based on feedback from early adopters, several capabilities are already on our roadmap for future MCP releases:

• Report generation on demand. Ask Claude to summarize today's average wait time, peak arrival windows, or no-show rate, and receive a plain-language answer rather than having to navigate a dashboard manually.
• Notification template editing. Adjust the wording of your SMS or email confirmations mid-session without leaving the Claude interface — useful when you want to add a parking note before a busy Saturday.
• Multi-location switching. If your account manages more than one venue, a future tool will let you specify a location by name and operate across queues in a single conversation.
• Recurring schedule rules. Define capacity limits or auto-pause windows that repeat weekly, so Claude can apply them with a single instruction rather than you repeating the setup each time.
• Guest preference notes. Attach a short internal note to a guest record — dietary requirements, accessibility needs, VIP status — that staff can reference when the party is called.

Building Your Own Integrations

MCP's open protocol means that developers on your team are not limited to the tools we ship. Any capability exposed through the waitlistapp.org REST API can, in principle, be wrapped as a custom MCP tool and surfaced in Claude. A common starting point is pairing queue data with a point-of-sale or reservation system so that seating a party in one platform automatically updates the other. If your team builds something noteworthy, we'd genuinely like to hear about it — community-contributed patterns often find their way into the official toolset.

Watching the Broader MCP Ecosystem

Anthropic's Model Context Protocol is still maturing. New client applications beyond Claude Desktop are already appearing — IDE plugins, mobile shells, and voice interfaces among them. As those surfaces stabilize, the same MCP configuration you set up today should work across all of them without modification, because the protocol is client-agnostic by design. Keep an eye on Anthropic's changelog; when they ship new sampling or tool-call features, we will evaluate whether they unlock queue management patterns that are not practical today.

Sharing Prompts with Your Team

One underused advantage of the conversational interface is that effective prompts can be saved and shared like any other text document. If a manager discovers a phrasing that reliably produces the right bulk-move behavior, or a host finds a shortcut that checks wait times without ambiguity, document it in your internal wiki or a shared note. A small library of tested prompts dramatically reduces the learning curve for new staff and ensures everyone is getting consistent results from the same underlying tools.

Staying on Pro

MCP access is a Pro-tier feature, and the depth of tooling will grow in step with that plan. If you are currently on a lower tier and evaluating whether the upgrade is worth it, the clearest test is this: count how many times per shift a staff member opens a browser tab just to perform a routine queue action. If that number is significant, the time saved by conversational queue management — no logins, no navigation, no context switching — is likely to justify the difference on its own.