Meet.bot MCP (Model Context Protocol)

A Model Context Protocol (MCP) server for the Meet.bot Booking Page API, enabling AI assistants to interact with scheduling and booking functionality.

What is this?

This MCP server connects AI assistants (like Claude, ChatGPT, and others that support MCP) to your Meet.bot account, allowing them to schedule meetings on your behalf. Instead of manually copying booking links or checking your calendar, you can simply ask your AI assistant to "schedule a 30-minute meeting with John next week" and it will handle the booking through your MeetBot scheduling pages.

How it works:

1. Connect your MeetBot API token to the MCP server
2. Configure your AI assistant to use this MCP server
3. Ask your AI assistant to schedule meetings - it can check your availability, find time slots, and book meetings directly through your MeetBot account

This is particularly useful for busy professionals who want to automate meeting scheduling and let their AI assistant manage their calendar intelligently.

If you don't have an account, you can get one for free at https://meet.bot

Features

• Complete API Coverage: Implements all endpoints from the Meet.bot Booking Page API v1
• Type Safety: Full TypeScript support with comprehensive type definitions
• Runtime Validation: Zod schemas for input validation and data integrity
• Authentication Support: Bearer token authentication
• Error Handling: Robust error handling with detailed error messages
• Health Checks: Built-in health monitoring using the /v1/pages endpoint
• MCP Protocol Compliance: Full Model Context Protocol server implementation
• Dual Mode Support: Run locally (stdio) or remotely (HTTP/SSE)
• Production Deployed: Live at https://mcp.meet.bot
• Production Ready: Thoroughly tested and validated for production use

Installation

npm install @meetbot/mcp

Quick Start

1. Install and Configure

# Install the package
npm install @meetbot/mcp

# Or install globally for CLI usage
npm install -g @meetbot/mcp

2. Authentication

Authentication is not a tool—it is connection-based:

• HTTP/SSE (remote, e.g. https://mcp.meet.bot): Send Authorization: Bearer <your_api_token> in the request headers when connecting. The server uses this token for all API calls in that session.
• Stdio (local): Set the MEETBOT_AUTH_TOKEN environment variable when starting the server (e.g. MEETBOT_AUTH_TOKEN=your_token npx @meetbot/mcp).

There is no configure_meetbot or similar tool; the AI uses the tools below and auth is handled by the connection.

3. Use the Available Tools

The MCP server provides the following tools:

Get Scheduling Pages

await get_scheduling_pages();
// Returns all scheduling pages for the authenticated user

Get Page Information

await get_page_info({
  page: "https://meet.bot/user/30min"
});
// Returns detailed information about a specific scheduling page

Get Available Slots

await get_available_slots({
  page: "https://meet.bot/user/30min",
  count: 10,
  start: "2025-01-01",
  end: "2025-01-31",
  timezone: "America/New_York",
  booking_link: true
});
// Returns available booking slots with optional filters

Book a Meeting

await book_meeting({
  page: "https://meet.bot/user/30min",
  guest_email: "guest@example.com",
  guest_name: "Jane Doe",
  notes: "Meeting to discuss project requirements",
  start: "2025-01-15T14:00:00Z"
});
// Books a new meeting slot

Health Check

await health_check();
// Verifies API connectivity using the /v1/pages endpoint

Webhooks

Get notified the moment a meeting is booked, rescheduled, or cancelled. Meet.bot POSTs a JWT-signed (HS256) JSON payload — the same contract as the partner webhook — to your URL for each event (booking_received, booking_rescheduled, booking_cancelled).

// List your webhooks
await list_webhooks();

// Create (omit id) or update (pass id) a webhook
await set_webhook({
  webhook_url: "https://your-app.example.com/meetbot-hook",
  description: "CRM sync",
  coverage: "all",   // or "selected" with pages: [<page id>, ...]
  scope: "self"      // team admins can use "team" to also receive teammates' bookings
});
// Returns the webhook including the shared secret used to verify the signature.

// Delete a webhook
await delete_webhook({ id: 123 });

Deployment Options

The MCP server can be run in two modes:

1. Local Mode (Stdio Transport)

For local integration with AI assistants like Claude Desktop. Uses stdio transport for communication.

# Run locally
npx @meetbot/mcp

# Or with environment variable
MEETBOT_AUTH_TOKEN="your_token" npx @meetbot/mcp

2. HTTP Mode (SSE Transport)

For remote deployment with HTTP/SSE transport. This allows the MCP server to be accessed over the network.

Running the HTTP Server

# Build and start the HTTP server
npm run build
npm run start:http

# Or with custom port
PORT=8080 npm run start:http

# Or run directly with npx
npx meetbot-mcp-http

Server Endpoints

• SSE Endpoint: GET /sse - Establishes an SSE connection for MCP communication
• Messages Endpoint: POST /messages?sessionId=<id> - Receives client messages
• Health Check: GET /health - Server health status

Authentication

All requests require a Bearer token in the Authorization header:

Authorization: Bearer <your-meetbot-api-token>

The same token is used to authenticate with the Meet.bot API.

Testing the HTTP Server

Local Testing:

# Health check (should fail without auth)
curl http://localhost:3000/health

# Health check with authentication
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:3000/health

# Connect to SSE endpoint
curl -N -H "Authorization: Bearer YOUR_TOKEN" http://localhost:3000/sse

# Or use the test script
./test-http-server.sh YOUR_TOKEN

Production Testing:

# Test the live deployment
curl -H "Authorization: Bearer YOUR_TOKEN" \
     https://mcp.meet.bot/health

# Expected response:
# {"status":"ok","service":"meetbot-mcp"}

Deployment

The HTTP server can be deployed to various platforms:

• Railway: railway up ✅ Live at https://mcp.meet.bot
• Fly.io: fly launch && fly deploy
• Google Cloud Run: Container-based deployment
• AWS App Runner: Container-based deployment
• Any VPS: Run with Node.js directly

Example: Connecting to Production

# Your MCP client should connect to:
# https://mcp.meet.bot/sse

# With Authorization header:
# Authorization: Bearer <your-meetbot-api-token>

Example Dockerfile:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist ./dist
EXPOSE 3000
CMD ["node", "dist/cli-http.js"]

MCP Integration

Using with AI Assistants

This MCP server can be integrated with AI assistants like Claude, ChatGPT, and others that support the Model Context Protocol.

Configuration Example

{
  "mcpServers": {
    "meetbot": {
      "command": "npx",
      "args": ["@meetbot/mcp"],
      "env": {
        "MEETBOT_AUTH_TOKEN": "your_bearer_token_here"
      }
    }
  }
}

Available MCP Tools

The server exposes 8 tools for AI assistants:

1. get_scheduling_pages - List all scheduling pages
2. get_page_info - Get page details
3. get_available_slots - Find available time slots
4. book_meeting - Book a meeting
5. health_check - Verify API connectivity using /v1/pages endpoint
6. list_webhooks - List your outbound booking webhooks
7. set_webhook - Create or update a webhook (booking_received / booking_rescheduled / booking_cancelled)
8. delete_webhook - Delete a webhook

Authentication is provided by the connection (Bearer token in HTTP header for remote, or MEETBOT_AUTH_TOKEN for local stdio)—there is no separate configure tool.

Testing and Validation

The package has been thoroughly tested and validated:

✅ MCP Protocol Compliance: Full JSON-RPC 2.0 support ✅ Tool Discovery: All 5 tools properly exposed ✅ Error Handling: Graceful error responses ✅ Type Safety: Complete TypeScript support ✅ Schema Validation: Input validation with Zod ✅ Production Ready: Tested with real MCP clients

Package Statistics

• Package Size: 12.8 kB (58.0 kB unpacked)
• Test Coverage: 21 passing tests
• Dependencies: 3 production dependencies
• TypeScript: 100% type coverage
• Build Status: ✅ Passing
• npm Registry: Published and available

Usage Examples

As a Library

import { MeetbotClient, MeetbotMCPServer } from '@meetbot/mcp';

// Use as a direct API client
const client = new MeetbotClient({
  authToken: 'your_token'
});

// Use as an MCP server
const server = new MeetbotMCPServer();
await server.run();

As an MCP Server

# Run the MCP server
npx @meetbot/mcp

# Or install globally
npm install -g @meetbot/mcp
meetbot-mcp

API Reference

MeetbotClient

The core API client for direct integration:

import { MeetbotClient } from '@meetbot/mcp';

const client = new MeetbotClient({
  authToken: 'your_token'
});

// Get all scheduling pages
const pages = await client.getPages();

// Get page information
const pageInfo = await client.getPageInfo({
  page: 'https://meet.bot/user/30min'
});

// Get available slots
const slots = await client.getSlots({
  page: 'https://meet.bot/user/30min',
  count: 20
});

// Book a meeting
const booking = await client.bookSlot({
  page: 'https://meet.bot/user/30min',
  guest_email: 'guest@example.com',
  guest_name: 'Jane Doe',
  start: '2025-01-15T14:00:00Z'
});

Data Types

All API responses are fully typed: