Whop MCP Server: The Complete Setup, Docs & Checkout API Guide

TL;DR

The two Whop MCP servers

The most common confusion is that "Whop MCP" can mean three related things: the read-only documentation server, the remote API server, or the local npm package that runs the API server as a subprocess. They are not interchangeable.

Whop Docs MCP

The Docs MCP gives an AI agent access to Whop developer documentation so it can look up API behavior, SDK usage, checkout details, and configuration examples. It is the right server when the agent is helping you build an app or write code and does not need to touch your live Whop data.

{
  "mcpServers": {
    "whop-docs": {
      "url": "https://docs.whop.com/mcp"
    }
  }
}

The broader documentation index is also available at docs.whop.com/llms.txt, which is useful when you want an agent to discover the docs before answering.

Whop API MCP remote

The API MCP is the server for live actions. Whop documents two remote transports: HTTP Streaming at https://mcp.whop.com/mcp and SSE at https://mcp.whop.com/sse. Use this when the agent needs to list products, inspect payments, create checkout configurations, review memberships, or call another Whop API endpoint.

@whop/mcp npm package

The npm package is the official local Whop API MCP server. It supports normal explicit tools, --tools=dynamic for large API surfaces, and --tools=code for a docs search tool plus Deno-sandboxed code execution against the TypeScript client. It also supports --client=cursor, --client=claude, --client=claude-code, and --client=openai-agents compatibility tuning.

export WHOP_API_KEY="your_api_key_here"
export WHOP_WEBHOOK_SECRET="optional_webhook_secret"
export WHOP_APP_ID="optional_app_id"
npx -y @whop/mcp@latest --client=cursor --tools=dynamic

When to use which

Setup by client

Use separate server names for docs and API access. That makes approval dialogs easier to read and reduces the chance that a documentation question turns into a live API call.

https://mcp.whop.com/sse

{
  "mcpServers": {
    "whop_sdk_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.whop.com/sse"]
    }
  }
}

claude mcp add --transport sse whop https://mcp.whop.com/sse

claude mcp add --transport stdio whop_sdk_api \
  --env WHOP_API_KEY="your_api_key_here" \
  --env WHOP_WEBHOOK_SECRET="optional_webhook_secret" \
  --env WHOP_APP_ID="optional_app_id" \
  -- npx -y @whop/mcp

{
  "mcpServers": {
    "whop-docs": {
      "url": "https://docs.whop.com/mcp"
    }
  }
}

{
  "mcpServers": {
    "whop_sdk_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.whop.com/sse"]
    }
  }
}

{
  "inputs": [
    {
      "id": "whop-api-key",
      "type": "promptString",
      "description": "Whop API key",
      "password": true
    }
  ],
  "servers": {
    "whop_sdk_api": {
      "command": "npx",
      "args": ["-y", "@whop/mcp"],
      "env": {
        "WHOP_API_KEY": "${input:whop-api-key}"
      }
    }
  }
}

{
  "mcpServers": {
    "whop_sdk_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.whop.com/sse"]
    }
  }
}

First safe test prompt

After setup, run a non-destructive prompt first:

List the available Whop MCP tools. Do not call any tool that creates, updates, deletes, refunds, cancels, retries, or sends data.

Authentication and API keys

Whop documents three credential paths for API usage. Choose the one that matches who owns the data and whose permissions should apply.

Permission examples

Whop permissions are scoped by endpoint. For example, checkout configuration creation requires checkout_configuration:create, plan:create, access_pass:create, access_pass:update, and checkout_configuration:basic:read. Payment refunds require payment-management permission plus supporting read scopes. Do not give an MCP workflow broad write access if it only needs to list records.

Read the full Whop API keys for MCP guide.

Checkout via Whop MCP

Checkout is the most valuable long-tail use case because it connects MCP setup to real developer work. A Whop agent can help create a checkout configuration, inspect checkout configuration IDs, prepare embed code, or attach metadata and affiliate attribution when the selected MCP server exposes the relevant API endpoint and your key has permission.

Anatomy of Whop checkout

Prompts that map to checkout API work

Embedded checkout examples

Whop documents the React package @whop/checkout and the WhopCheckoutEmbed component. Use the official checkout docs as the source of truth before shipping customer-facing checkout code.

import { WhopCheckoutEmbed } from "@whop/checkout/react";

export default function Checkout() {
  return (
    <WhopCheckoutEmbed
      planId="plan_XXXXXXXXX"
      returnUrl="https://yoursite.com/checkout/complete"
      affiliateCode="username"
    />
  );
}

Affiliate attribution

Whop's affiliate guide documents links with ?a=<username> and a default 30-day attribution cookie window. API and embed surfaces also expose affiliate_code or affiliateCode. Use clean links for official docs and disclose affiliate links separately when monetizing this site.

Read the full Whop checkout via MCP guide.

What you can do with Whop API MCP

Exact tools vary by package version, client, transport, and filtering flags. The official npm package currently exposes a broad Whop API surface, including read and write tools. Use the Whop MCP tools reference to map the surface before approving calls.

Sandbox mode

Use sandbox first when you are testing checkout, payment, or membership flows. Whop documents a sandbox dashboard and sandbox API base URL at https://sandbox-api.whop.com/api/v1. The remote mcp.whop.com page does not currently advertise a separate sandbox MCP URL, so the conservative path is to run @whop/mcp locally with a sandbox API key.

export WHOP_API_KEY="your_sandbox_api_key"
npx -y @whop/mcp@latest --tools=dynamic

Safety and security

A write-capable MCP server with a real Whop API key can change products, create checkout configurations, refund payments, cancel memberships, send messages, or perform other business actions depending on scopes. Treat it like any production integration.

1. Use least-privilege keys. Grant only the scopes needed for the workflow.
2. Start in sandbox. Test checkout and payment behavior away from live customers.
3. Separate docs from API access. Use Docs MCP for docs questions and API MCP only when live actions are needed.
4. Read approval dialogs. Inspect the tool name and arguments, not just the agent's summary.
5. Filter tools. Use --tools=dynamic, --operation=read, --resource=..., or exclusion flags to reduce the available tool surface.
6. Do not commit secrets. Use environment variables, prompted inputs, or client secret storage.
7. Pin and review dependencies. Whop documents @latest and mcp-remote@latest for convenience, but production workflows should review package changes before upgrading.

Troubleshooting

Whop MCP vs hosted gateways

The official Whop server is the right default when you want a direct Whop API or documentation connection. Hosted gateways make sense when you want scheduling, no-code orchestration, multi-app workflows, or a client that does not support MCP directly.

Related guides

Use these narrower guides when you already know which client or workflow you are setting up.

• Whop MCP Claude setup

  Claude Desktop and Claude Web setup notes, verification prompts, and safety checks.

• Whop MCP Cursor setup

  Project-level and global Cursor configuration for Whop Docs MCP and API MCP.

• Whop MCP VS Code setup

  GitHub Copilot MCP configuration, prompted secrets, and workspace setup.

• Whop MCP API key guide

  Company API keys, App API keys, OAuth tokens, and permission selection.

• Whop MCP checkout docs

  Checkout configuration, checkout sessions, embedded checkout, and affiliate attribution.

• Whop MCP troubleshooting

  Fix client visibility, auth, permissions, tool overload, and startup failures.

• Whop API keys for MCP

  Company keys, App keys, OAuth, permissions, prompted secrets, and safe rotation.

• Whop checkout via MCP

  Checkout configurations, sessions, embedded checkout, affiliate attribution, and approval prompts.

• Whop MCP tools reference

  Map checkout, payments, memberships, products, finance, courses, community, and platform tools before approving calls.

FAQ

Official sources

Use these as the source of truth when details change:

• Whop AI and MCP guide
• Whop Remote MCP Server
• Whop API getting started
• Whop API authentication
• Whop permissions guide
• Whop embedded checkout
• Create checkout configuration
• Whop affiliates guide
• Whop sandbox guide
• @whop/mcp npm package
• Model Context Protocol specification
• Cursor MCP docs
• VS Code MCP docs
• Windsurf MCP docs
• Claude Code MCP docs