Connect Google Calendar to Claude: Control Calendars and Permissions

If you need to connect Google Calendar to Claude to automate scheduling, manage complex availability constraints, or control workspace calendar permissions, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function calls and Google Calendar's REST APIs. You can either build and maintain this infrastructure 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 Google Calendar to ChatGPT or explore our broader architectural overview on connecting Google Calendar to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise scheduling environment is a significant engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Google's specific pagination and time zone constraints. Every time an endpoint changes or you need to support a new calendar scope, 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 Google Calendar, connect it natively to Claude, and execute complex scheduling workflows using natural language.

The Engineering Reality of the Google Calendar API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Google's API is painful. You are not just integrating a generic calendar - you are integrating an enterprise ecosystem with decades of legacy design patterns.

If you decide to build a custom MCP server for Google Calendar, you own the entire API lifecycle. Here are the specific challenges you will face:

Recurring Events vs. Single Instances Google Calendar handles recurring events via a master event ID. If an LLM attempts to update a specific occurrence (like "cancel next week's sync") by modifying the master event, it will break the entire series. To handle this correctly, your integration must know when to expand a recurring event into single instances using the singleEvents parameter, fetch the specific instance ID, and apply the update there. Truto handles the schema translation so Claude understands this distinction natively.

Strict RFC3339 Timestamp Enforcement Google APIs require highly specific data formats that LLMs frequently struggle to generate consistently from scratch. The Calendar API strictly enforces RFC3339 timestamps for start and end times (e.g., 2024-05-15T10:00:00-07:00). If an LLM sends an ISO8601 string without a time zone offset, or a Unix timestamp, the API rejects it with a 400 Bad Request. A managed MCP server enforces these schemas, ensuring Claude passes valid formats.

Complex Free/Busy Payload Structures The freeBusy endpoint is notoriously difficult for AI agents to navigate. It requires passing an items array of specific calendar IDs, limits groupExpansionMax to 100, and returns a nested, interval-based object mapping availability. If you expose this raw schema directly to Claude, the model will frequently hallucinate calendar IDs or misinterpret overlapping intervals. Truto's tools provide structured definitions that guide the LLM to query exactly what it needs.

Strict Rate Limits and Normalization Google Calendar enforces strict API quotas per user and per project. If your AI agent gets stuck in a loop trying to bulk-update events, it will trigger a 429 Too Many Requests error. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Google API returns an HTTP 429, Truto passes that error directly to the caller.

But, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your AI agent or client architecture is responsible for implementing the necessary retry and exponential backoff logic, but Truto guarantees you receive clean, predictable headers to base that logic on.

How to Generate a Google Calendar MCP Server with Truto

Truto dynamically generates MCP tools from the Google Calendar API's resource definitions and documentation. Each MCP server is scoped to a single integrated account (a connected Google instance for a specific tenant).

The server URL contains a cryptographic token that encodes which account to use, what tools to expose, and when the server expires. This means the MCP server is fully self-contained - the URL alone is enough to authenticate and serve tools, with no additional configuration needed on the client side.

You can create this MCP server in two ways: via the Truto UI for manual testing, or via the Truto API for programmatic deployment.

Method 1: Via the Truto UI

If you are an IT admin or developer setting up an agent for internal use, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Google Calendar account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read and write methods, restrict to specific tags).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers for your users on the fly, use the API. This endpoint validates the account, generates a secure token stored in KV, and returns the endpoint.

Request:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Calendar Access",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    }
  }'

Response:

{
  "id": "mcp_abc123",
  "name": "Claude Calendar Access",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, you need to register it with Claude. Anthropic supports remote MCP connections via both the web UI and the local desktop application.

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

For most users, adding the server via the UI is the simplest method.

1. Open Claude and navigate to Settings → Integrations (or Settings → Connectors in ChatGPT/enterprise tiers).
2. Click Add Custom Connector or Add MCP Server.
3. Give the server a name (e.g., "Google Calendar (Truto)").
4. Paste the URL you generated in the previous step.
5. Click Add.

Claude will immediately perform the MCP initialization handshake, fetching the list of available Google Calendar tools. No further configuration is required.

Method B: Via Manual Config File (Claude Desktop)

If you are managing Claude Desktop deployments programmatically or prefer local configuration, you can add the server by modifying the claude_desktop_config.json file. Truto's remote endpoints can be accessed using an SSE client adapter.

Open your configuration file (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\\Claude\\claude_desktop_config.json on Windows) and add the following JSON:

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

Restart Claude Desktop. The application will use npx to spawn the SSE client, which connects to your Truto MCP URL and registers the tools.

Hero Tools for Google Calendar

Truto normalizes dozens of Google Calendar endpoints into clean, heavily documented MCP tools. Here are the highest-leverage tools available for your AI agents.

list_all_google_calendar_events

This is the primary tool for reading calendar data. It retrieves events from a specified calendar. Truto's schema explicitly instructs the LLM on how to handle parameters like timeMin, timeMax, and singleEvents (which is critical for expanding recurring meetings into actual instances).

Contextual usage notes: Agents should always pass singleEvents: true and an orderBy: "startTime" value when looking for a user's upcoming schedule to avoid returning massive blocks of recurring master events.

"What are my meetings for tomorrow? Please check my primary calendar and make sure to expand any recurring events so I see the actual meeting times."

create_a_google_calendar_event

Creates a new event on the specified calendar. The agent must provide a calendarId (usually primary) and an event object containing RFC3339 timestamps for start and end times, along with attendees and a summary.

Contextual usage notes: LLMs are prone to guessing calendar IDs. Instruct your agent to always query the list_all_google_calendar_calendar_lists tool first if it needs to book on a secondary or shared calendar.

"Schedule a 45-minute sync with sarah@example.com for next Tuesday at 2 PM Pacific Time. Title it 'Q3 Roadmap Alignment' and add a Google Meet link."

list_all_google_calendar_free_busy

Retrieves free/busy availability information for a list of calendars or groups within a defined time range. This is essential for AI agents acting as executive assistants or automated schedulers.

Contextual usage notes: The tool requires an items array of calendar IDs. The agent must provide a strict timeMin and timeMax. The response is an array of busy intervals, meaning the agent must calculate the "free" time by finding the gaps.

"Check the free/busy availability for both myself and the engineering-leads@example.com group next Thursday between 10 AM and 4 PM EST. Find me three 30-minute slots where everyone is free."

update_a_google_calendar_event_by_id

Updates an existing event in the specified calendar. The agent must provide the calendarId and the specific event id to execute the patch.

Contextual usage notes: Because Google Calendar requires the specific instance ID for recurring events, an agent should always list the events first, identify the target id, and then call this tool.

"Push my 1:1 with Alex tomorrow back by 30 minutes. If he has a conflict, let me know before you move it."

create_a_google_calendar_acl

Creates an access control rule for a calendar, granting permissions to users, groups, or domains.

Contextual usage notes: This tool is incredibly powerful for IT administration agents. It requires the calendar_id and a request body defining the scope (who gets access) and the role (e.g., reader, writer, owner).

"Share the 'Marketing Campaigns 2026' calendar with the new contractor, david@example.com, and give him read-only access."

list_all_google_calendar_calendar_lists

Returns the calendars on the authenticated user's calendar list. This is the foundational discovery tool an agent uses to understand what calendars a user has access to before it attempts to read or write events.

Contextual usage notes: Agents should use this to resolve calendar names (like "PTO Calendar" or "Ops On-Call") into actual calendarId strings required by the other endpoints.

"List all the shared calendars I have access to. I am looking for the one related to Q3 Product Launches."

To view the complete inventory of available tools, including contact search, channel watching, and settings endpoints, visit the Google Calendar integration page.

Workflows in Action

Giving Claude access to these tools enables highly autonomous, multi-step scheduling and administration workflows. Here is how specific personas can leverage this MCP server in the real world.

Scenario 1: Resolving a Double-Booked Executive (EA Agent)

An AI assistant managing an executive's calendar needs to identify and resolve a scheduling conflict.

"I see I am double-booked tomorrow at 1 PM. Please find out which meetings are overlapping, check the availability of the attendees for the internal meeting, and reschedule the internal one to later in the week when everyone is free."

Tool Sequence:

1. list_all_google_calendar_events: The agent queries tomorrow's schedule and identifies the two overlapping events (one client sync, one internal team sync).
2. list_all_google_calendar_free_busy: The agent extracts the attendees from the internal team sync and queries their availability for the next three days.
3. update_a_google_calendar_event_by_id: The agent finds a valid gap, patches the internal meeting with the new RFC3339 timestamps, and updates the calendar.

Result: The executive's schedule is cleared, the internal team is automatically notified via Google's native update emails, and the AI agent replies confirming the new time.

Scenario 2: Automated Offboarding & Revoking Access (SecOps Agent)

An IT administrator needs to ensure a departing employee no longer has access to sensitive departmental calendars.

"We are offboarding jason@example.com. Please audit all our shared departmental calendars, find where he has access, and revoke his permissions immediately."

Tool Sequence:

1. list_all_google_calendar_calendar_lists: The agent retrieves the IDs of all shared departmental calendars managed by the admin account.
2. list_all_google_calendar_acl: The agent iterates through the ACL rules for each calendar, searching for the scope matching jason@example.com.
3. delete_a_google_calendar_acl_by_id: When a match is found, the agent calls the delete tool, passing the specific rule ID and the calendar ID.

Result: The agent systematically purges the user's access across the workspace without the IT admin having to click through dozens of Google Workspace settings pages.

Scenario 3: Cross-Team Availability Sync (Sales Manager Agent)

A sales manager needs to coordinate a complex cross-functional pitch.

"I need to schedule a 1-hour pitch with the Acme Corp team next week. It needs to include myself, a solutions architect (sam@example.com), and the legal reviewer (legal@example.com). Please find the earliest available block and put a hold on our calendars."

Tool Sequence:

1. list_all_google_calendar_free_busy: The agent queries the free/busy data for all three internal users simultaneously for the upcoming week.
2. create_a_google_calendar_event: The agent parses the intersecting free time, selects the earliest 1-hour block, and books the event, adding all three users as attendees.

Result: A complex multi-person scheduling task that typically takes 10 minutes of manual calendar comparison is executed in seconds.

Security and Access Control

When connecting an LLM to enterprise calendar infrastructure, security is paramount. Truto provides four distinct configuration layers to lock down your MCP server and prevent hallucinated destructive actions.

• Method Filtering (config.methods): Restrict the server to specific operation types. Setting this to ["read"] ensures the LLM can only execute get and list tools. It physically cannot modify events or ACLs, preventing accidental deletions.
• Tag Filtering (config.tags): Limit the exposed tools to specific resource categories. You can create an MCP server that only exposes ["events"] tools, ensuring the model cannot view or modify workspace ACL rules or user settings.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL is enough to access the tools. Setting this to true requires the client to also pass a valid Truto API token in the Authorization header, adding a second authentication layer for zero-trust environments.
• Expiration (expires_at): For temporary tasks (like a contractor needing scheduling access for a week), you can set a TTL. Truto uses Cloudflare KV and Durable Objects to automatically destroy the token and credentials at the exact specified time.

Connecting Google Calendar to Claude doesn't require building and hosting a custom integration layer from scratch. By leveraging a managed MCP server, you eliminate the operational burden of token lifecycles, schema mapping, and edge-case pagination. You get a secure, dynamic integration out of the box, allowing your AI agents to safely read, analyze, and orchestrate complex scheduling workflows on day one.