# How to connect Google Calendar to OpenClaw (no API keys)

> Connect Google Calendar to OpenClaw with ClawLink in one click — 44 tools your AI agent can call from chat via hosted OAuth. No API keys, no manual setup.

Web version: https://claw-link.dev/openclaw/google-calendar

The usual route to Google Calendar access for OpenClaw is an MCP server you configure and keep running, plus your own OAuth app or API keys. ClawLink gives OpenClaw a more practical Google Calendar setup: install one ClawHub skill, connect Google Calendar in the browser, and OpenClaw can call real Google Calendar actions from any chat surface with no auth, token refresh, or tool wiring to build yourself.

**Start here:** install the ClawLink plugin (`openclaw plugins install clawhub:clawlink-plugin`), pair it in the browser, then connect the app in the ClawLink dashboard. The interactive install prompt is on the web version of this page: https://claw-link.dev/openclaw/google-calendar

## Setup

It takes three steps to connect OpenClaw to Google Calendar.

1. **Install ClawLink** — add the plugin to OpenClaw once.
2. **Connect Google Calendar** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask OpenClaw in plain English.

**Alternative for any agent (no plugin needed):** if the OpenClaw plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect google-calendar  # connect Google Calendar (browser OAuth)
npx -y @useclawlink/cli actions google-calendar  # list available actions
npx -y @useclawlink/cli run google-calendar <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The setup prompt above does all of this in one paste. By hand, it is one install command plus a browser approval:

```bash
openclaw plugins install clawhub:clawlink-plugin
```

Then ask OpenClaw to set up ClawLink. It starts browser pairing and prints an approval link — open it, approve the device, return to the chat, and say `done`. Finally, connect Google Calendar in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking OpenClaw:

> Create a Google Calendar event called "Design review" tomorrow at 14:00 for 90 minutes (event_duration_hour 1, event_duration_minutes 30) with sam@acme.com as an attendee, and show me the arguments before you create it.

### Using a different agent?

The OpenClaw plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Google Calendar is connected in the dashboard, that agent calls the same 44 Google Calendar tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Google Calendar MCP for OpenClaw

Looking for a Google Calendar MCP server for OpenClaw? ClawLink connects Google Calendar to OpenClaw and exposes 44 Google Calendar tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using Hermes instead? The [Hermes Google Calendar integration](https://claw-link.dev/hermes/google-calendar) works the same way.

Every other route to Google Calendar in OpenClaw starts the same way: create a Google Cloud project, enable the Calendar API, configure an OAuth consent screen, download a credentials.json, then authenticate a CLI against it. ClawLink removes that entire prerequisite. You connect Google Calendar in the browser on Google's own consent screen, and OpenClaw calls the tools from the next message — no Cloud project, no client secret on your machine, nothing to keep running.

## Do you need a Google Cloud project for OpenClaw and Google Calendar?

Not with ClawLink, and that is the main difference between this page and every guide above it in the search results. It is worth being precise about which route needs what, because they are genuinely different tradeoffs rather than better and worse:

- **ClawLink** — connect in the browser through Google's consent screen. No Cloud project, no OAuth client, no `credentials.json` on disk, and nothing to keep running. ClawLink holds the token and refreshes it; you revoke access at myaccount.google.com/permissions or by deleting the connection.
- **The `gog` CLI**, which is what most OpenClaw guides and the r/openclaw replies recommend, keeps the token on your own machine and answers to nobody else. The cost is the setup those guides describe: your own Google Cloud project, the Calendar API enabled, an OAuth consent screen, a desktop client, and a downloaded `credentials.json`. Pick this if you specifically do not want a third party holding a token.
- **Google's own Calendar MCP server** (`calendarmcp.googleapis.com/mcp/v1`) is free and official, exposing eight tools. It is in Developer Preview at the time of writing and still needs you to create an OAuth client and enable the Calendar MCP API, so it is aimed at Workspace developers rather than at getting an agent working this afternoon.
- **A self-hosted community server** such as `nspady/google-calendar-mcp` gives you the full surface and full control, and you own running and updating it.

ClawLink asks Google for calendar and calendar.events access — enough to read, create, and modify events on the calendars the account can reach. That is real access, so connect the account whose calendars you actually want the agent working on, and use a secondary account if you would rather keep a personal calendar out of scope.

## What the OpenClaw Google Calendar integration can do

44 Google Calendar tools are ready for OpenClaw once the account is connected. The 30 below are the ones people reach for most; your agent can call all 44.

### 30 of 44 Google Calendar tools for OpenClaw

| Tool | What it does |
|---|---|
| **Create event** `googlecalendar_create_event` | Create a Google Calendar event |
| **Duplicate calendar** `googlecalendar_duplicate_calendar` | Duplicate a Google Calendar |
| **Events get** `googlecalendar_events_get` | Get a Google Calendar event by event id |
| **Events instances** `googlecalendar_events_instances` | List instances of a recurring Google Calendar event |
| **Events list** `googlecalendar_events_list` | List events from a Google Calendar |
| **Events move** `googlecalendar_events_move` | Move a Google Calendar event to another calendar |
| **Find event** `googlecalendar_find_event` | Find a Google Calendar event |
| **Find free slots** `googlecalendar_find_free_slots` | Find free time slots across calendars |
| **Get calendar** `googlecalendar_get_calendar` | Get Google Calendar metadata by calendar id |
| **Get current date time** `googlecalendar_get_current_date_time` | Get current date and time with timezone context |
| **List calendar resources** `googlecalendar_list_calendar_resources` | List calendar resources (rooms/equipment) |
| **List calendars** `googlecalendar_list_calendars` | List Google Calendars available to the connected account |
| **Patch event** `googlecalendar_patch_event` | Patch a Google Calendar event |
| **Quick add** `googlecalendar_quick_add` | Create a Google Calendar event from a natural language description |
| **Update event** `googlecalendar_update_event` | Update a Google Calendar event |
| **Acl get** `googlecalendar_acl_get` | Retrieves a specific access control rule for a calendar |
| **Acl list** `googlecalendar_acl_list` | Retrieves the list of access control rules (ACLs) for a specified calendar, providing the |
| **Calendar list get** `googlecalendar_calendar_list_get` | Retrieves metadata for a SINGLE specific calendar from the user's calendar list by its calendar |
| **Colors get** `googlecalendar_colors_get` | Returns the color definitions for calendars and events |
| **Events list all calendars** `googlecalendar_events_list_all_calendars` | Return a unified event list across all calendars in the user's calendar list for a given time |
| **List buildings** `googlecalendar_list_buildings` | Lists all buildings for a Google Workspace customer account with full details including |
| **Settings get** `googlecalendar_settings_get` | Return a single user setting for the authenticated user |
| **Settings list** `googlecalendar_settings_list` | Returns all user settings for the authenticated user |
| **Acl insert** `googlecalendar_acl_insert` | Creates an access control rule for a calendar |
| **Acl patch** `googlecalendar_acl_patch` | Updates an existing access control rule for a calendar using patch semantics (partial update) |
| **Acl update** `googlecalendar_acl_update` | Updates an access control rule for the specified calendar |
| **Acl watch** `googlecalendar_acl_watch` | Watch for changes to ACL resources |
| **Calendar list insert** `googlecalendar_calendar_list_insert` | Inserts an existing calendar into the user's calendar list, making it visible in the UI |
| **Calendar list patch** `googlecalendar_calendar_list_patch` | Updates an existing calendar on the user's calendar list using patch semantics |
| **Calendar list update** `googlecalendar_calendar_list_update` | Updates a calendar list entry's display/subscription settings (color, visibility, reminders |

## Example prompts

**Book a 90-minute meeting**

> Create a Google Calendar event called "Design review" tomorrow at 14:00 for 90 minutes (event_duration_hour 1, event_duration_minutes 30) with sam@acme.com as an attendee, and show me the arguments before you create it.

**Read the right calendar**

> List my Google Calendars with their ids first, then show me everything on the team calendar for next week — use that calendar's id, not primary.

**Find a slot across people**

> Use find_free_slots across my calendar and sam@acme.com between Tuesday and Thursday, 09:00-17:00 Europe/London, and give me the three longest free blocks.

**Clean up a recurring series**

> Find my recurring "Standup" event, list its upcoming instances, and move just next Friday's instance to 10:30 without touching the rest of the series.

## Google Calendar tool arguments that trip agents up

These are the failures we actually see in production, with the argument names and limits taken from the live tool schemas. They are worth knowing because an agent will usually guess wrong on the first try.

- **`start_datetime` is the only required argument on `googlecalendar_create_event`, and it is a flat string — not Google's nested `start` object.** The Calendar API itself takes `\{"start": \{"dateTime": "…"\}\}`, so agents trained on Google's own docs send that shape and the call fails with `arguments.start_datetime is required`. Pass `start_datetime: "2026-01-16T13:00:00"` instead. The schema asks for a naive datetime and pairs it with a separate `timezone` argument; a trailing `Z` is accepted in practice, but naive plus `timezone` is the form the tool documents.
- **`event_duration_minutes` accepts 0-59 only.** For anything an hour or longer use `event_duration_hour` (0-24) — a 90-minute event is `event_duration_hour: 1` plus `event_duration_minutes: 30`. Passing 60 fails with `Input should be less than or equal to 59`. The default duration is 30 minutes.
- **Calendar id casing differs between tools.** `googlecalendar_create_event` takes `calendar_id` (snake_case, defaults to `primary`), while `googlecalendar_events_list` requires `calendarId` (camelCase, no default). Copying one into the other is a common failure.
- **There is no `end_datetime` argument, and passing one does not error.** Duration comes only from `event_duration_hour` and `event_duration_minutes`, so "book 2pm to 4pm" sent as `start_datetime` plus `end_datetime` silently produces a 30-minute event at 2pm. This is the quietest failure on the toolkit — the call returns success and the calendar is simply wrong. Tell the agent to convert an end time into a duration before it creates the event.
- **`attendees` is a list of plain email strings.** Pass `["sam@acme.com"]`, not `[\{"email": "sam@acme.com"\}]` — the live schema types the array items as strings.
- **A calendar id is either `primary` or the calendar's email address.** Shared and secondary calendars are addressed by that address, which is why an agent left on the default reads the wrong calendar rather than erroring.
- **`googlecalendar_find_free_slots` defaults to `items: ["primary"]`** and caps at 50 calendars per query, so pass the calendar ids explicitly when checking a team's availability.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Google Calendar working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a Google Calendar app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect Google Calendar through the hosted browser flow and ClawLink keeps the token lifecycle out of your app code. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Google Calendar. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Google Calendar actions to the runtime in a format your agent can reliably use. | 44 tools for Google Calendar are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Google Calendar to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for OpenClaw users instead. You install the plugin once, connect Google Calendar in the browser, and the 44 tools above work from chat. There is no SDK, no config file, and no API key handling. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### OpenClaw installed the Google Calendar skill but can't call the tools
The ClawHub skill teaches OpenClaw about Google Calendar, but the calls run through the ClawLink plugin and your connected account. Make sure Google Calendar is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

### Connection succeeds but no tools appear
Reconnect Google Calendar from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Google Calendar tools
Google Calendar tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Google Calendar call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Google Calendar returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### arguments.start_datetime is required
This is the single most common Google Calendar failure we see, and the cause is almost always the same: the agent sent Google Calendar API's own nested shape, `\{"summary": "…", "start": \{"dateTime": "2026-01-16T13:00:00Z"\}, "end": \{"dateTime": "…"\}\}`. That is exactly what Google's API reference documents, so a model reaching for its training data writes it — but this tool takes flat arguments, so `start` is ignored and the required `start_datetime` is genuinely absent. Retrying the same payload cannot fix it; we have seen a single agent replay it more than fifty times. The working form is `start_datetime: "2026-01-16T13:00:00"` with `timezone` set separately, and the duration expressed as `event_duration_hour` / `event_duration_minutes` rather than an end time.

Ask the agent to diagnose it:

```text
Retry the event creation, but first show me the exact arguments you are going to send. start_datetime must look like 2026-01-16T13:00:00 with no Z and no offset, and put the zone in the timezone argument instead.
```

### Tool 'googlecalendar_list_events' not found
The tool exists, but not under the name the agent guessed. The real names read verb-last: it is `googlecalendar_events_list`, not `list_events`; `googlecalendar_patch_event`, not `events_patch`; and `googlecalendar_calendar_list_get`, not `calendar_list_list`. ClawLink returns a "Did you mean" suggestion with the closest matches on every miss, so tell the agent to read that line and retry with the suggested name rather than inventing another variant. Asking it to call `clawlink_list_tools` first is the reliable fix.

Ask the agent to diagnose it:

```text
Run clawlink_list_tools for google-calendar and show me the exact tool names that came back. Then retry using the real name, not a guess.
```

### OpenClaw says Google Calendar is connected but can't see your events, or returns the wrong ones
Almost always the calendar id, not the connection. Calendar tools default to `primary`, which is the connected account's own calendar — so if your events live on a shared calendar, a work calendar, or a second account you shared into this one, the agent is reading an empty or unrelated calendar and reporting exactly what it found. Ask it to run `googlecalendar_list_calendars` first and show you the ids, then repeat the request naming the calendar you meant; the id is the calendar's email address, not its display name. This is also why sharing a calendar with a bot account is not enough on its own — the agent still has to be told to read it.

Ask the agent to diagnose it:

```text
Run googlecalendar_list_calendars and show me every calendar id and its summary. Do not filter the list. Then re-run my request against the calendar id I pick.
```

### Input should be less than or equal to 59 on parameter `event_duration_minutes`
The duration is split across two arguments and the minutes field only accepts 0-59. Anything an hour or longer goes in `event_duration_hour`, which accepts 0-24. A 90-minute meeting is `event_duration_hour: 1` with `event_duration_minutes: 30`; a two-hour block is `event_duration_hour: 2`. If you omit both, the event is created 30 minutes long.

Ask the agent to diagnose it:

```text
Create the event again using event_duration_hour for the whole hours and event_duration_minutes for the remainder only. Show me both values before you send it.
```

### The event was created successfully but it is 30 minutes long instead of the time range you asked for
You asked for 2pm to 4pm and got 2pm to 2:30pm, with no error anywhere. `googlecalendar_create_event` has no `end_datetime` argument — duration is expressed only through `event_duration_hour` and `event_duration_minutes`, and an unrecognised end time is discarded rather than rejected. The event is created, the call reports success, and only the calendar shows the mistake. This is common enough that it is worth checking first whenever a created event has the right title and start time but the wrong length. Ask the agent to convert the end time into a duration and patch the event.

Ask the agent to diagnose it:

```text
That event is the wrong length. googlecalendar_create_event has no end_datetime argument — convert my time range into event_duration_hour and event_duration_minutes, then patch the existing event and show me the arguments you send.
```

### Connected account is not in an ACTIVE state. Current status is "REVOKED"
The Google grant behind this connection was withdrawn — either from myaccount.google.com/permissions, by an admin on a Workspace account, or by deleting the connection's access. Nothing on the ClawLink side can revive it and retrying the call will keep returning the same status. Reconnect Google Calendar from the dashboard, complete Google's consent screen in the same browser session, then start a fresh chat so OpenClaw picks up the working connection. A status of INITIALIZING instead means the consent flow was started but never finished.

Ask the agent to diagnose it:

```text
Reconnect Google Calendar from the dashboard first, then run clawlink_list_integrations and show me the status you get back before retrying anything.
```

### OAuth finished in the browser but the account is still missing
Try reconnecting Google Calendar and complete the consent flow in the same browser session. Partial OAuth approvals or switching accounts mid-flow can leave the connection incomplete.

### Is there a OpenClaw Google Calendar integration?
Yes. ClawLink is the fastest way to connect OpenClaw to Google Calendar: link your Google Calendar account once in the browser and OpenClaw can call the Google Calendar API through 44 ready-made tools — no custom code or token handling.

### How do I add Google Calendar to OpenClaw with ClawLink?
Paste the setup prompt from this page into OpenClaw. It installs the ClawLink Google Calendar skill from ClawHub, then you click Connect in the dashboard to authorize Google Calendar. OpenClaw calls the tools from the next message — no config files or API keys to manage.

### How long does it take to connect Google Calendar to OpenClaw?
About two minutes. Sign in, click Connect next to Google Calendar in the dashboard, authenticate, and OpenClaw can use it from the next chat message.

### Why use ClawLink instead of wiring Google Calendar up myself?
The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Google Calendar working from chat.

### Do I need a Google Cloud project to connect Google Calendar to OpenClaw?
Not with ClawLink. The guides that tell you to create a Cloud project, enable the Calendar API, configure a consent screen and download a credentials.json are describing the `gog` CLI route, where the OAuth client is yours. ClawLink uses a hosted connection instead: you click Connect, approve on Google's own consent screen, and the tools work from the next message. You still see and control the grant under Third-party apps and services in your Google account.

### Why can OpenClaw connect to my Google Calendar but not see my events?
Because the calendar tools default to `primary`, the connected account's own calendar. If your events live on a shared, work, or secondary calendar, the agent is reading a different calendar and truthfully reporting that it found nothing — or returning events you did not ask about. Ask it to run `googlecalendar_list_calendars`, then repeat the request naming the calendar id you want; ids are email addresses, not display names. Sharing a calendar with the connected account makes it reachable but does not make it the default.

### How do I create a Google Calendar event longer than an hour from OpenClaw?
Use `event_duration_hour` for the hours and `event_duration_minutes` only for the remainder, because the minutes argument accepts 0-59 and rejects 60. A 90-minute event is `event_duration_hour: 1` with `event_duration_minutes: 30`. Left unset, a new event is 30 minutes long.

### Is it safe to connect my personal Google Calendar to OpenClaw?
The honest version: ClawLink asks Google for calendar and calendar.events access, which is enough to read, create, edit and delete events on the calendars that account can reach. That is real access and we would rather say so than call it narrower than it is. What it avoids is a standing credential — there is no client secret or token file sitting on your machine or server, the grant is listed under Third-party apps and services in your Google account, and one click at myaccount.google.com/permissions ends it. The agent also acts only when you ask, rather than polling. If that reach is more than you want on a personal calendar, connect a secondary Google account and share into it just the calendars the agent should see.

### OpenClaw installed the Google Calendar skill but can't call the tools
The ClawHub skill teaches OpenClaw about Google Calendar, but the calls run through the ClawLink plugin and your connected account. Make sure Google Calendar is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

## Related

- [Connect Google Super](https://claw-link.dev/openclaw/google-super) — Unified access to multiple Google services in one integration
- [Google Drive tools](https://claw-link.dev/openclaw/google-drive) — Upload, search, and manage files
- [OpenClaw Google Analytics integration](https://claw-link.dev/openclaw/google-analytics) — Connect Google Analytics properties through hosted Google OAuth