How to Set Up an MCP Server for Calendly

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.

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:

{
  "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.

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.

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.

Give Your Agents a Workspace for Meeting Artifacts

Pair Calendly scheduling with persistent file storage. Fast.io gives agents 50GB free storage, built-in document intelligence, and an MCP server that works alongside Calendly. No credit card required. Built for mcp server calendly workflows.

Sign Up Free

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.

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.

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 Fast.io MCP server. 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 + Fast.io 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 Fast.io workspace via the Fast.io 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

Fast.io's free agent tier includes 50GB storage, 5,000 credits per month, and 5 workspaces, with no credit card required. 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.

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.