# How to Set Up an MCP Server for Calendly

Calendly's official MCP server lets AI agents check availability, book meetings, and manage scheduling links through the Model Context Protocol. This guide walks through authentication, tool configuration, and practical workflows for connecting Claude, ChatGPT, or custom agents to Calendly's scheduling API.

Source: https://fast.io/resources/mcp-server-for-calendly/
Last reviewed: 2026-04-13

## What the Calendly MCP Server Does

Calendly launched its official MCP server in March 2026, giving AI agents direct access to scheduling workflows without custom API wrappers. The server lives at `https://mcp.calendly.com` and exposes over 40 tools mapped to Calendly's API v2, covering event types, availability, meetings, and organization management.

Before MCP, connecting an AI agent to Calendly meant writing REST API integration code, handling pagination, managing token refresh, and building tool definitions from scratch. The MCP server packages all of that into a standardized protocol that any MCP-compatible client can consume.

**What agents can do through the Calendly MCP server:**

- Check a user's available time slots for any event type
- Create one-time scheduling links for specific invitees
- Book meetings directly, including setting location and duration
- Cancel or reschedule existing events
- Update availability rules and scheduling windows
- Create and modify event types with custom configurations
- Mark invitees as no-shows and manage attendance records
- List routing form submissions for intake workflows

Each tool includes annotation metadata with human-readable titles and behavioral hints like `readOnlyHint`, `destructiveHint`, and `idempotentHint`. These annotations help AI agents make smarter decisions about which actions are safe to take autonomously versus which ones need human confirmation.

The server works on all Calendly pricing tiers, including the free plan. Some tools, like `meetings-create_event_invitee` for direct booking, require a paid Calendly subscription.

## What to check before scaling mcp server for calendly

The Calendly MCP server uses OAuth 2.1 with Authorization Code flow and PKCE. Personal access tokens are not supported for MCP connections. This means your MCP client needs to handle dynamic client registration (DCR) before it can authenticate.

Here is how the authentication flow works:

### 1. Initial Discovery

When your MCP client connects to `https://mcp.calendly.com`, the server returns a 401 response pointing to its protected resource metadata. The client fetches this metadata to discover the authorization server location and the two available scopes: `mcp:scheduling:read` and `mcp:scheduling:write`.

### 2. Register Your Client

Your client calls the DCR endpoint at `https://calendly.com/oauth/register` with a registration payload:

```json
{
  "client_name": "My Scheduling Agent",
  "redirect_uris": ["https://myapp.example.com/callback"],
  "grant_types": ["authorization_code"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none"
}
```

The registration returns a `client_id` that your client uses for all subsequent auth requests. Note that Calendly MCP uses public client mode only, so there is no `client_secret`.

### 3. Authorize and Get Tokens

With the `client_id` in hand, your client initiates the standard OAuth authorization code flow with PKCE (S256). The user sees a Calendly consent screen, approves access, and your client exchanges the authorization code for access and refresh tokens.

**Redirect URI requirements:**

- Must use HTTPS (localhost is exempted for development)
- No wildcard patterns allowed
- Must match exactly what you registered

### 4. Use the Access Token

Pass the access token as a Bearer token in request headers. The MCP client handles this automatically once authenticated. Tokens expire and need refresh, which compliant MCP clients manage in the background.

Most mainstream MCP clients already support this OAuth flow. Claude Desktop, ChatGPT (Plus and above), and Claude Code all handle the DCR and PKCE steps internally, so end users just see an "Authorize Calendly" prompt.

## Connecting Calendly MCP to Claude and ChatGPT

The fast way to start using Calendly MCP is through a consumer AI client that supports MCP natively. Both Claude and ChatGPT have built-in Calendly connectors that handle the OAuth flow automatically.

### Claude Setup

1. Open Claude and click **Customize** in your account settings
2. Select **Connect your tools**
3. Search for Calendly and select it
4. Approve access permissions in the Calendly authorization window
5. Toggle the Calendly connector on when starting new conversations

Once connected, you can ask Claude to check your availability, create scheduling links, or book meetings through natural language. Claude maps your request to the appropriate MCP tool, executes it, and returns the result.

### ChatGPT Setup

ChatGPT requires a Plus subscription or higher for custom MCP connectors. The free tier does not support this.

1. Go to **Settings**, then **Apps**
2. Enable **Developer mode** under Advanced settings
3. Create an app using the MCP server URL: `https://mcp.calendly.com`
4. Authorize Calendly access when prompted
5. Enable Calendly in new chats via the **+** icon menu

### Custom Agent Setup

If you are building your own agent, you need an MCP client library that supports Streamable HTTP transport and OAuth 2.1 with DCR. The MCP TypeScript SDK and Python SDK both support this. Point your client at `https://mcp.calendly.com` and let the OAuth discovery flow handle registration automatically.

```typescript
import { Client } from "@modelcontextprotocol/sdk/client";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/transport";

const transport = new StreamableHTTPClientTransport({
  url: "https://mcp.calendly.com",
});

const client = new Client({
  name: "scheduling-agent",
  version: "1.0.0",
});

await client.connect(transport);
const tools = await client.listTools();
```

Your client needs to implement the OAuth callback handler for the DCR flow. The MCP SDK documentation covers this in detail.

## Practical Scheduling Workflows

Once connected, here are concrete workflows that work well with Calendly MCP.

### Workflow 1: Smart Meeting Prep

An agent checks your Calendly for upcoming meetings, pulls attendee information, then prepares briefing notes. The agent calls `meetings-list_events` to get your schedule, `meetings-list_event_invitees` for each event to identify attendees, and then searches your workspace files for any prior communication or documents related to those contacts.

### Workflow 2: Availability-Aware Scheduling Links

Instead of sending a generic Calendly link, your agent generates a one-time link with specific availability windows. It calls `event_types-list_event_type_available_times` to find open slots that match both parties' preferences, then uses `scheduling_links-create_scheduling_link` to generate a link restricted to those windows.

### Workflow 3: Automated Follow-Up After No-Shows

When a meeting goes unattended, your agent uses `meetings-create_invitee_no_show` to mark the record, then drafts a rescheduling message with a fresh booking link from `scheduling_links-create_scheduling_link`. This turns a missed meeting into an automatic rebooking attempt.

### Workflow 4: CRM-Connected Booking

Pair Calendly MCP with a CRM MCP server so your agent can look up a contact, check their last interaction, and propose a meeting time that accounts for your availability. The agent chains tools across both MCP servers: CRM lookup first, then Calendly availability check, then link generation.

### Workflow 5: Routing Form Triage

If you use Calendly routing forms to qualify inbound requests, your agent can call `routing_forms-list_routing_form_submissions` to pull new submissions, evaluate them against your criteria, and either book a meeting immediately or add the lead to a nurture sequence.

Each of these workflows combines Calendly MCP tools with other data sources. The power of MCP is that agents can chain tools from different servers in a single conversation without needing purpose-built integrations between each service.

## Where Agent Output Goes After the Meeting

Scheduling is just the trigger. The real value shows up when agents produce artifacts around meetings: briefing docs, follow-up summaries, action items, and shared files. Those outputs need somewhere to live where both the agent and the human team can access them.

This is where a persistent workspace matters. If your agent generates a meeting prep document or a post-meeting summary, you need a place to store it that is not buried in a chat log.

[Fastio](https://fast.io) provides intelligent workspaces designed for this kind of agent-to-human handoff. An agent can create a workspace, upload meeting artifacts, and share them with the right people, all through the [Fastio MCP server](/storage-for-agents/). When Intelligence Mode is enabled, uploaded documents are automatically indexed for semantic search, so anyone on the team can ask questions about meeting notes or find specific action items later.

**A practical Calendly + Fastio flow:**

1. Agent checks Calendly for tomorrow's meetings via MCP
2. Agent prepares briefing docs from CRM data and prior notes
3. Agent uploads briefings to a Fastio workspace via the Fastio MCP server
4. Agent creates a branded share link and sends it to the meeting organizer
5. After the meeting, the agent uploads the summary and action items
6. Team members search across all meeting artifacts using Intelligence Mode

Fastio offers a [14-day Business Trial](https://fast.io/pricing/) to get started with shared workspaces and AI indexing. The MCP server is available over Streamable HTTP at `/mcp` and legacy SSE at `/sse`, so it works alongside the Calendly MCP server in any multi-tool agent setup.

Other storage options work too. You could use a Google Drive MCP server, an S3 integration, or local filesystem storage. The key point is that scheduling data from Calendly becomes more useful when paired with a persistent layer for the documents and context surrounding those meetings.

## Troubleshooting and Limitations

The Calendly MCP server is still in its first release, so there are boundaries worth knowing about.

### Authentication Issues

The most common setup problem is MCP clients that do not support Dynamic Client Registration. If your client expects a pre-issued `client_id` and `client_secret`, it will not work with Calendly's MCP server. Check that your MCP client supports OAuth 2.1 with DCR before troubleshooting further.

If you see repeated 401 errors after successful authorization, verify that your redirect URI matches exactly what you registered, including trailing slashes and protocol scheme.

### Transport Requirements

The Calendly MCP server requires MCP specification version 2025-03-26 or later and Streamable HTTP transport. Older clients using only stdio transport cannot connect to remote MCP servers like Calendly's. Verify your client supports remote HTTP-based MCP connections.

### Tool-Specific Limitations

- **Direct booking** (`meetings-create_event_invitee`) requires a paid Calendly plan. Free tier users can create scheduling links but cannot book meetings programmatically.
- **Routing forms** are only available on Teams plans and above.
- **Organization management tools** require appropriate admin permissions. An agent authenticated as a regular member cannot invite or remove organization members.

### Rate Limiting

Calendly's API v2 rate limits apply to MCP tool calls. If your agent makes rapid successive calls, you may hit throttling. Build in reasonable delays between batch operations, and use list endpoints with filtering rather than fetching individual records in loops.

### Self-Hosting

You cannot self-host the Calendly MCP server. It runs exclusively at `https://mcp.calendly.com` and is managed by Calendly. If you need a custom MCP server that wraps Calendly's REST API with different authentication (like personal access tokens), community implementations exist on GitHub, but they are not officially supported.

### Scope Limitations

The current release exposes scheduling and organization tools. Calendly features like analytics, integrations management, and webhook configuration are not yet available through MCP. Expect the tool surface to expand in future releases.

## Frequently asked questions

### Can AI agents book Calendly meetings?

Yes. AI agents can book Calendly meetings through the official MCP server at mcp.calendly.com. The server exposes tools for checking availability, creating scheduling links, and directly booking meetings with invitees. Direct booking via the create_event_invitee tool requires a paid Calendly plan, but creating one-time scheduling links works on all tiers including the free plan.

### How do I automate Calendly with Claude?

Open Claude, go to Customize, select Connect your tools, and search for Calendly. Approve the OAuth authorization and toggle the connector on. Once connected, you can ask Claude to check your calendar, create scheduling links, update availability, or cancel meetings using natural language. Claude maps your requests to the appropriate Calendly MCP tools automatically.

### Is there an MCP plugin for Calendly?

Calendly provides an official MCP server at mcp.calendly.com, launched in March 2026. It exposes over 40 tools covering event types, availability, meetings, scheduling links, routing forms, and organization management. The server uses OAuth 2.1 authentication and works with any MCP-compatible client including Claude, ChatGPT, and custom agents.

### What authentication does the Calendly MCP server use?

The Calendly MCP server uses OAuth 2.1 with Authorization Code flow and PKCE. It requires Dynamic Client Registration (DCR), meaning your MCP client registers itself automatically and receives a client_id. Personal access tokens are not supported for MCP connections. The two available scopes are mcp:scheduling:read and mcp:scheduling:write.

### Can I use Calendly MCP with a custom AI agent?

Yes. Any MCP client that supports Streamable HTTP transport and OAuth 2.1 with DCR can connect to the Calendly MCP server. The MCP TypeScript SDK and Python SDK both support these requirements. Point your client at https://mcp.calendly.com and the OAuth discovery flow handles registration automatically.

### Does Calendly MCP work on the free plan?

The Calendly MCP server works on all pricing tiers including the free plan. However, some tools have plan restrictions. Direct meeting booking via create_event_invitee requires a paid plan, and routing form tools require a Teams plan or higher. Core features like listing events, checking availability, and creating scheduling links work on all plans.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.