Connect Apple Calendar to Claude: Search Schedules & Update Events

If you need to connect Apple Calendar to Claude to build autonomous scheduling assistants, search meeting availability, or automate event updates, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's JSON-RPC tool calls and Apple's underlying protocol. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses OpenAI, check out our guide on connecting Apple Calendar to ChatGPT or explore our broader architectural overview on connecting Apple Calendar to AI Agents.

Giving a Large Language Model (LLM) read and write access to Apple Calendar (iCloud) is a highly specific engineering challenge. You are not dealing with a modern RESTful JSON API. You are dealing with CalDAV (RFC 4791) - an XML-heavy extension of WebDAV. Every time you want Claude to search a schedule, the underlying integration must generate strict XML reports. Every time Claude needs to update an event, the system must handle raw .ics file manipulation.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Apple Calendar, connect it natively to Claude, and execute complex scheduling workflows using natural language without writing CalDAV parsers.

The Engineering Reality of the Apple Calendar API

A custom MCP server is a self-hosted integration layer that translates an LLM's intent into executable HTTP requests. The MCP standard itself is an elegant way for models to discover tools. The reality of implementing it against Apple Calendar is brutal.

If you decide to build a custom MCP server for Apple Calendar, you are responsible for abstracting away decades-old protocols so the LLM doesn't hallucinate invalid requests. Here are the specific challenges you will face:

The CalDAV XML Nightmare Apple Calendar relies heavily on PROPFIND and REPORT HTTP methods with complex XML bodies. For example, discovering a calendar's URL requires parsing a 207 Multi-Status XML response to find the principal_path, and then making a second PROPFIND request to locate the calendar-home-set. If you expose these raw CalDAV verbs to Claude, the model will frequently fail to construct valid XML namespaces (xmlns:d="DAV:"). A managed MCP server handles this translation, exposing clean JSON parameters to Claude and handling the XML generation natively on the backend.

No HTTP PATCH (Full Resource Replacement Only) Updating an event in Apple Calendar is dangerous if handled incorrectly. iCloud does not support HTTP PATCH. To modify a meeting time, you must first GET the event as a raw text/calendar resource (the complete .ics file). You then modify the specific VEVENT properties in memory, and perform a full PUT of the entire string. If an LLM attempts to just send the updated timestamp, the entire event payload will be corrupted. The server must orchestrate this read-modify-write cycle.

ETag Collisions and Concurrency Because updates require full resource replacement, concurrency is a major issue. If an event changes while your agent is processing it, your PUT request will overwrite the newer data. You must implement If-Match headers using the ETag retrieved during the initial GET request. If the ETag doesn't match, the request fails, and the agent must retry.

Polling Over Webhooks iCloud does not offer modern HTTP webhooks for event changes. To keep an agent synchronized with an Apple Calendar, you must implement RFC 6578 sync-collection. This requires polling the server with a sync_token.

Handling Rate Limits Apple enforces rate limits that will block aggressive polling or rapid event generation. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the Apple Calendar API returns HTTP 429 Too Many Requests, Truto passes that error directly to Claude. Truto normalizes upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your MCP client or agent framework is entirely responsible for reading these headers and executing retry/backoff logic.

Instead of building CalDAV parsers, ETag managers, and XML builders from scratch, you can use Truto. Truto normalizes the underlying complexity, exposing Apple Calendar's operations as ready-to-use, documented MCP tools.

How to Generate an Apple Calendar MCP Server

Truto derives MCP tools dynamically from your integration's configuration and documentation schemas. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM receives high-quality descriptions and exact JSON schemas for every calendar operation.

Each MCP server is scoped to a single connected Apple Calendar account. The generated server URL contains a cryptographic token that securely encodes the account mapping and filter configurations. You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For internal automation or quick testing, generating the server from the dashboard is the fastest route:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select the connected Apple Calendar account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can restrict the server to specific methods (e.g., read only) or specific tags.
5. Click Create and securely copy the generated MCP server URL. You will not be able to see the raw token again.

Method 2: Via the API

If you are building an application where your users bring their own Apple Calendars, you should provision the MCP servers programmatically after they connect their accounts.

Send a POST request to the /integrated-account/:id/mcp endpoint:

const response = await fetch('https://api.truto.one/integrated-account/ia_abc123/mcp', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${TRUTO_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Claude Calendar Assistant",
    config: {
      methods: ["read", "write"], // Allows GET, LIST, CREATE, UPDATE, DELETE
      require_api_token_auth: false
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/tkn_789xyz...

The returned URL is fully self-contained. The token handles the routing to the specific user's iCloud partition host and authenticates the downstream requests.

Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional code. All communication happens over HTTP POST via JSON-RPC 2.0 messages.

Method A: Via the Claude UI (Claude Web / ChatGPT)

If you are using the consumer-facing interfaces for Claude or ChatGPT, you can add custom connectors directly in the settings:

1. Open Claude and navigate to Settings -> Integrations (or Settings -> Connectors depending on your plan tier).
2. Click Add MCP Server (or Add Custom Connector).
3. Paste the mcpServer.url generated in the previous step.
4. Click Add.

Claude will immediately send an initialize handshake to the URL, discover the available tools, and load them into the context window.

Method B: Via Manual Config File (Claude Desktop)

For developers running Claude Desktop locally, you configure the server using the claude_desktop_config.json file. Because Truto uses Server-Sent Events (SSE) for its remote MCP transport, you must use the official @modelcontextprotocol/server-sse proxy to bridge the standard IO protocol Claude expects to the HTTP endpoints Truto provides.

Locate your configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Update the file to include the Apple Calendar server:

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

Restart Claude Desktop. The calendar tools will now be available.

Hero Tools for Apple Calendar

Truto exposes the complexity of CalDAV as clean, descriptive tools. Here are the most critical operations you should expose to Claude for Apple Calendar automation.

list_all_apple_calendar_calendars

Before Claude can query events, it needs to know which calendars exist. This tool executes a PROPFIND request against the user's principal path, returning the displayname, calendar_color, and sync_token for all available calendars.

"Claude, list all the calendars on my Apple account and tell me the ID of the one named 'Work'."

apple_calendar_calendars_search

This is the workhorse tool for retrieving events. It executes a REPORT request (specifically a calendar-query per RFC 4791) against a specific calendar collection. It filters and lists VEVENT data, returning 207 Multi-Status XML parsed into JSON.

"Search my 'Work' calendar for any events scheduled for next Tuesday between 9 AM and 5 PM."

create_a_apple_calendar_event

This tool handles the HTTP PUT required to create an event. It automatically constructs a valid iCalendar VCALENDAR string and generates a new UUID for the resource filename. It manages the If-None-Match: * header internally to ensure the new event doesn't overwrite an existing one.

"Schedule a 45-minute sync with the engineering team for tomorrow at 10 AM on my primary calendar. Title it 'Architecture Review'."

update_a_apple_calendar_event_by_id

Because iCloud lacks PATCH support, this tool abstracts the read-modify-write cycle. Claude passes the targeted updates, and the server replaces the entire iCalendar resource via HTTP PUT, automatically appending the required .ics suffix to the resource ID.

"Push my 'Architecture Review' meeting back by one hour, and update the description to include 'Please review the attached design doc before joining'."

get_single_apple_calendar_calendar_home_by_id

Crucial for deep discovery workflows. This tool issues a PROPFIND to discover the calendar-home-set URL. Because Apple load-balances accounts across different partition hosts (e.g., p34-caldav.icloud.com), this tool tells the system exactly which host to route subsequent calendar and event requests to.

"Execute a discovery check to find my current iCloud partition host and calendar home URL."

To view the complete schema definitions, response payloads, and the full list of available tools, review the Apple Calendar Integration Documentation.

Workflows in Action

Once connected, Claude can orchestrate multi-step CalDAV operations seamlessly. Here is how Claude translates natural language into concrete Apple Calendar API workflows.

Scenario 1: The Executive Assistant Adjustment

A user needs to reorganize a busy afternoon without manually dragging events across the screen.

"I'm running late. Find my 2:00 PM 'Q3 Planning' meeting on my Work calendar. Push it to 2:30 PM, and if I have anything scheduled at 3:00 PM, cancel it to make room."

Execution Steps:

1. Claude calls list_all_apple_calendar_calendars to resolve the string "Work calendar" to a specific collection ID.
2. Claude calls apple_calendar_calendars_search using the calendar ID and a time boundary for the afternoon to retrieve the events.
3. Claude parses the results, locating the "Q3 Planning" event and identifying a conflicting 3:00 PM event.
4. Claude calls update_a_apple_calendar_event_by_id, targeting the "Q3 Planning" event to modify the start and end times in the VEVENT block.
5. Claude calls delete_a_apple_calendar_event_by_id targeting the 3:00 PM event, completing the reorganization.

sequenceDiagram
    participant User as End User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant API as Apple Calendar (iCloud)
    
    User->>Claude: "Push my 2PM meeting to 2:30..."
    Claude->>Truto: tools/call (search_calendars)
    Truto->>API: REPORT /calendars (XML)
    API-->>Truto: 207 Multi-Status
    Truto-->>Claude: JSON Array of VEVENTs
    Claude->>Truto: tools/call (update_event_by_id)
    Truto->>API: GET .ics (fetch ETag)
    Truto->>API: PUT .ics (replace VCALENDAR)
    API-->>Truto: 200 OK
    Truto-->>Claude: Update successful
    Claude->>Truto: tools/call (delete_event_by_id)
    Truto->>API: DELETE .ics
    API-->>Truto: 204 No Content
    Truto-->>Claude: Deletion successful
    Claude-->>User: "I have adjusted your schedule."

Scenario 2: Project Provisioning

A project manager wants to isolate a new initiative into a dedicated schedule.

"Create a new calendar called 'Project Phoenix' and assign it a red color. Once it's created, schedule daily standups for 9:30 AM every weekday for the next two weeks."

Execution Steps:

1. Claude calls create_a_apple_calendar_calendar, supplying the display name "Project Phoenix" and the color code. The MCP server executes a MKCALENDAR request.
2. The MCP server returns the new calendar_id.
3. Claude loops through a date array, calling create_a_apple_calendar_event for each weekday, passing the new calendar_id to populate the standups.
4. Claude informs the user that the calendar is provisioned and populated.

flowchart TD
    A["Parse intent:<br>Provision Calendar"] --> B["Tool: create_a_apple_calendar_calendar"]
    B -->|MKCALENDAR request| C["Extract new calendar_id"]
    C --> D["Generate dates for<br>weekday standups"]
    D --> E["Loop: create_a_apple_calendar_event"]
    E -->|PUT raw VCALENDAR text| F["Return success to user"]

Security and Access Control

Giving an LLM access to a user's primary calendar requires strict guardrails. A rogue prompt could theoretically instruct an agent to wipe out months of historical data. Truto's MCP tokens provide granular enforcement mechanisms at generation time:

• Method Filtering (config.methods): You can restrict the MCP server to safe operations. Setting methods: ["read"] ensures the server will only generate tools for GET and LIST methods. DELETE tools are entirely scrubbed from the server's capability list.
• Tag Filtering (config.tags): You can scope the server to specific functional areas. For example, if a token is generated with tags: ["discovery"], Claude will only be able to see calendar_home and principal endpoints, preventing access to event payloads.
• Expiration (expires_at): Ideal for temporary agent sessions. You can set an ISO datetime. Once passed, the underlying KV storage automatically expires, the token is invalidated, and all tool calls immediately fail.
• Extra Authentication (require_api_token_auth): By default, possession of the MCP URL is sufficient to call tools. For high-security environments, enabling this flag requires the MCP client to also pass a valid Truto API token in the Authorization header, validating the caller's identity against your application.

Moving Past CalDAV and Into Agentic Scheduling

Building an AI agent that works reliably with Apple Calendar requires bridging a massive generational gap in API design. Apple Calendar relies on CalDAV, requiring XML namespaces, HTTP REPORT polling, and raw .ics file manipulation. LLMs thrive on clean JSON and clear schemas.

A managed MCP server acts as this bridge. By generating dynamic, documentation-driven tools, Truto allows your Claude agents to interact with iCloud calendars as if they were modern REST endpoints. You stop fighting PROPFIND syntax and start focusing on the intelligence of your scheduling prompts.