Connect Cal.com to Claude: Automate Scheduling Workflows

To connect Cal.com to Claude, you need a Model Context Protocol (MCP) server. This server acts as a translation layer, converting the LLM's standardized tool calls into Cal.com's specific REST API requests. You can either build and maintain this translation layer yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Cal.com to ChatGPT or explore our broader architectural overview on connecting Cal.com to AI Agents.

Giving a Large Language Model (LLM) read and write access to a scheduling platform is an engineering challenge. You have to handle authentication, map JSON schemas to MCP tool definitions, and deal with upstream rate limits. Every time Cal.com updates an endpoint, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Cal.com, connect it natively to Claude, and execute complex scheduling workflows using natural language.

The Engineering Reality of the Cal.com API

A custom MCP server is a self-hosted integration layer. As we discussed when connecting Anthropic to Claude, while the open standard provides a predictable way for models to discover tools over JSON-RPC 2.0, the reality of implementing it against vendor APIs is entirely different. If you decide to build a custom MCP server for Cal.com, you own the entire API lifecycle.

Cal.com's API introduces several specific integration challenges that break standard CRUD assumptions:

Timezone Normalization and ISO 8601 Strictness Scheduling APIs are notorious for timezone drift. Cal.com requires strict ISO 8601 formatting for all date-time parameters. LLMs frequently hallucinate date formats or attempt to pass human-readable strings like "next Tuesday at 3 PM". Your MCP schema must strictly define the expected string formats and provide explicit instructions to the LLM to calculate the correct UTC offsets before making the API call.

Event Type Polymorphism When creating a booking via the API, Cal.com allows routing through either an eventTypeId (integer) or an eventTypeSlug (string). Depending on how the user prompts Claude, the model might try to use the human-readable slug instead of the ID. Your tool definitions must account for both input paths and ensure the LLM knows how to fetch the mapping if it only has the human-readable name.

Rate Limits and 429s Cal.com enforces strict rate limits on API requests. When an LLM executes a multi-step orchestration loop - like pulling a list of 50 bookings, checking the schedule for each, and updating multiple event types - it can easily trigger an HTTP 429 Too Many Requests error. Truto normalizes upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec—a crucial feature when connecting Apono to Claude as well—but it passes the 429 error directly back to the caller. Your AI agent must be responsible for its own retry and exponential backoff logic.

How to Generate a Cal.com MCP Server

As we saw when connecting Affinity to Claude, Truto eliminates the need to manually code tool definitions. Because Truto's architecture treats integration behavior as data rather than code, it automatically generates MCP tools from the integration's resource definitions and documentation records.

There are two ways to generate an MCP server for your connected Cal.com account.

Method 1: Via the Truto UI

For quick testing and manual setup, you can generate the server directly from the dashboard.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Cal.com account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (name, allowed methods, tags, and expiry).
6. Copy the generated MCP server URL.

Method 2: Via the Truto API

For programmatic provisioning - such as generating a dedicated MCP server for each of your end-users - you can use the Truto REST API. The API validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL.

POST /integrated-account/:id/mcp
{
  "name": "Claude Cal.com Server",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": null
}

The response returns the database record along with the secure URL:

{
  "id": "abc-123",
  "name": "Claude Cal.com Server",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL contains a cryptographic token that encodes which account to use and what tools to expose. It is fully self-contained.

How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with Claude. You can do this through the Claude UI or via a manual configuration file.

Method 1: Via the Claude UI

If you are using Claude on the web or the Claude Desktop app with UI connector support:

1. Open Claude and navigate to Settings.
2. Select Integrations or Connectors.
3. Click Add MCP Server (or Add Custom Connector).
4. Paste the Truto MCP URL you generated in the previous step.
5. Click Add.

Claude will immediately perform an initialization handshake with the Truto endpoint, request the list of available tools, and make them available in your chat interface.

Method 2: Via Manual Configuration File

If you are running Claude Desktop locally and prefer file-based configuration, you can add the server to your claude_desktop_config.json file. Because Truto provides a remote HTTP endpoint, you use the official SSE (Server-Sent Events) client wrapper provided by the MCP project.

{
  "mcpServers": {
    "calcom-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The application will execute the npx command, establishing a persistent SSE connection to the Truto MCP server.

sequenceDiagram
    participant C as Claude Desktop
    participant S as SSE Client
    participant M as Truto MCP Server
    participant API as Cal.com API
    C->>S: Read config.json
    S->>M: Connect via HTTP/SSE
    M-->>S: Return capabilities & tools
    S-->>C: Register tools
    C->>S: JSON-RPC tool call<br>(create_booking)
    S->>M: POST /mcp/:token
    M->>API: POST /v1/bookings
    API-->>M: 200 OK
    M-->>S: Parsed Response
    S-->>C: MCP Result Content

Security and Access Control

Giving an LLM unconstrained access to a production scheduling environment is risky. Truto provides native access controls at the MCP token level to limit the blast radius of AI agent actions.

• Method Filtering: Restrict the MCP server to specific operation types. By passing config.methods: ["read"], the LLM can only execute get and list operations. It can check schedules and read bookings, but it cannot create or delete them.
• Tag Filtering: Scope the server to specific resource categories. If you only want the LLM to manage event types, you can pass config.tags: ["events"] to exclude tools related to teams or billing.
• Token Authentication: By default, the MCP URL is the only authentication required. For enterprise environments, setting require_api_token_auth: true forces the MCP client to also provide a valid Truto API token in the Authorization header, ensuring only authenticated internal systems can use the server.
• Ephemeral Access: Use the expires_at field to create temporary credentials. This is ideal for granting an AI agent temporary access to resolve a specific scheduling conflict. Once the timestamp passes, the server automatically revokes access.

Cal.com Tool Inventory for Claude

When Claude connects to the Truto MCP server, it dynamically discovers the available Cal.com tools. Truto generates highly descriptive JSON schemas for each endpoint, complete with pagination instructions and required field definitions.

Hero Tools

These are the most frequently used tools for agentic scheduling workflows.

list_all_calcom_bookings

• Description: Retrieves a paginated list of all bookings in Cal.com, returning details like the booking ID, title, description, hosts, status, and cancellation reasons.
• Example Prompt: "Pull a list of all my bookings for next week and summarize any that have a 'cancelled' status."

create_a_calcom_booking

• Description: Creates a new booking. Requires a start time, attendee details, and either an eventTypeId or eventTypeSlug.
• Example Prompt: "Create a 30-minute booking for john@example.com starting tomorrow at 2 PM UTC using the 'discovery-call' event type slug."

list_all_calcom_schedules

• Description: Retrieves all schedules for the authenticated user, returning the schedule name, timezone, and explicit availability blocks.
• Example Prompt: "Check my current schedules and tell me what my availability looks like for Fridays."

list_all_calcom_event_types

• Description: Retrieves all configured event types, including their duration, title, description, and location details (e.g., Zoom, Google Meet).
• Example Prompt: "List all my event types and tell me which ones are configured for 60 minutes."

update_a_calcom_schedule_by_id

• Description: Modifies an existing schedule. Requires the scheduleId and accepts updated fields for the name, timezone, and availability arrays.
• Example Prompt: "Update the schedule with ID 45 to change the timezone to 'Europe/London' and block out 12 PM to 1 PM every day."

Full Tool Inventory

Here is the complete inventory of additional Cal.com tools available. For full schema details, visit the Cal.com integration page.

• get_single_calcom_booking_by_id: Get booking details by id in Cal.com.
• delete_a_calcom_schedule_by_id: Delete a schedule by id in Cal.com.
• delete_a_calcom_team_by_id: Delete a team by id in Cal.com.
• create_a_calcom_team: Create a team in Cal.com with a required name.
• list_all_calcom_teams: Get list of teams in Cal.com.
• update_a_calcom_team_by_id: Update a team by id in Cal.com.
• get_single_calcom_team_by_id: Get a team by id in Cal.com.
• create_a_calcom_event_type: Create an event type in Cal.com.
• update_a_calcom_event_type_by_id: Update an event type by id in Cal.com.
• get_single_calcom_event_type_by_id: Get event type by id in Cal.com.
• delete_a_calcom_event_type_by_id: Delete an event type by id in Cal.com.
• list_all_calcom_calendars: Get all connected calendars in Cal.com.
• create_a_calcom_schedule: Create a new schedule with specific availability.
• get_single_calcom_schedule_by_id: Get schedule details by id in Cal.com.

Workflows in Action

Connecting Claude to Cal.com unlocks powerful, multi-step orchestration capabilities. Here is how specific personas use these tools in the real world.

Scenario 1: Autonomous Booking Triage

Executive assistants spend hours manually resolving calendar conflicts. An AI agent can handle this autonomously.

Prompt: "Check my bookings for tomorrow. If there is a conflict with the 10 AM executive sync, find the conflicting booking, cancel it, and tell me who I need to email to reschedule."

Execution Steps:

1. Claude calls list_all_calcom_bookings with query parameters filtering for tomorrow's date.
2. The model analyzes the returned array, identifying a booking that overlaps with the 10 AM slot.
3. Claude extracts the ID of the conflicting booking.
4. Claude calls update_a_calcom_booking_by_id (or the equivalent cancellation endpoint) passing the ID and setting the status to cancelled.
5. Claude formulates a natural language response detailing the cancelled booking and the attendee's email address.

Scenario 2: Dynamic Sales Routing Setup

Sales operations teams frequently need to provision new event types and update schedules for specific regional teams.

Prompt: "Create a new 30-minute discovery event type for the EMEA sales team. Then, update their primary schedule to only allow bookings between 9 AM and 1 PM GMT."

Execution Steps:

1. Claude calls list_all_calcom_teams to find the ID for the "EMEA sales team".
2. Claude calls create_a_calcom_event_type, passing the team ID, a length of 30, and the title "Discovery Call".
3. Claude calls list_all_calcom_schedules to find the primary schedule associated with that team.
4. Claude extracts the scheduleId.
5. Claude calls update_a_calcom_schedule_by_id, passing the ID, setting the timeZone to Europe/London, and overwriting the availability array to [ { startTime: "09:00", endTime: "13:00" } ].

Strategic Wrap-Up

Building a custom MCP server for Cal.com forces your engineering team to absorb the maintenance burden of schema mapping, authentication, and endpoint deprecations. Every time Cal.com releases a new feature, your integration layer requires a code deployment.

By using Truto, you shift that burden to a managed platform. The MCP tools are generated dynamically from documentation records, ensuring that Claude always has an accurate, up-to-date understanding of the Cal.com API. You get granular security controls, unified rate limit headers, and a frictionless connection process, allowing your team to focus on building agentic workflows rather than maintaining API plumbing.