How to Connect Calendly to OpenClaw: Smart Meeting Scheduler

Most professionals spend 30 minutes per meeting just on logistics: checking availability, sending confirmation emails, prepping background on who they are meeting with, writing follow-up notes afterward. Connect Calendly to OpenClaw and your AI agent handles all of it. You message “who do I have tomorrow?” on Telegram and get a briefing with attendee backgrounds, talking points, and relevant docs pulled together automatically.

This guide walks through the full integration: creating a Calendly personal access token, writing the OpenClaw skill file, and setting up automations that run before and after every meeting. If OpenClaw is already running on your machine, expect about 20 minutes of setup time.

---

What This Integration Does

Once connected, OpenClaw becomes a conversational layer on top of your Calendly scheduling. Instead of opening the Calendly dashboard, you message your agent and it handles the API calls.

Here is what you can do:

• Check your upcoming schedule by asking “What meetings do I have this week?”
• Look up event details and invitee information for any scheduled meeting
• Get pre-meeting briefings with attendee names, companies, and any custom form responses they submitted
• Receive proactive reminders via Telegram or WhatsApp before meetings start
• Draft follow-up messages after meetings based on the agenda and attendee context

The agent talks to Calendly’s REST API (v2) using a personal access token. No third-party middleware, no paid connectors. Data flows directly between your machine and Calendly’s servers.

---

Before You Start

Three things need to be in place:

1. OpenClaw installed and running on your machine. If you have not set it up yet, follow our OpenClaw setup guide. That guide covers installation, workspace files, memory, and Telegram configuration.

2. A Calendly account on a paid plan (Standard, Teams, or Enterprise). The free plan supports the basic API, but webhook subscriptions for automated triggers require a paid tier. If you only want manual queries (asking your agent about your schedule), the free plan works.

3. A text editor to create the skill file. VS Code, Cursor, or any editor that handles Markdown is fine.

---

Step 1: Create a Calendly Personal Access Token

Calendly uses personal access tokens for API authentication. This is simpler than OAuth and works well for individual integrations where you are the only user.

1. Log into Calendly and click your profile icon in the top-left corner
2. Go to Settings > Integrations
3. Scroll down to API & Webhooks and click Get a token now (this redirects to the developer portal)
4. Alternatively, go directly to https://calendly.com/integrations/api_webhooks
5. Click Generate New Token
6. Give it a descriptive name: OpenClaw Integration
7. Copy the token immediately. Calendly shows it once. If you lose it, you need to generate a new one.

Store the Token Safely

Do not paste the token into your skill file. Store it in a .env file:

# ~/.env or ~/openclaw/.env
CALENDLY_API_TOKEN=eyJraWQiOiIxY2UxZ...your-token-here

OpenClaw reads environment variables at runtime. This keeps the secret out of any file your agent might share or log.

---

Step 2: Write the OpenClaw Calendly Skill

OpenClaw skills are Markdown files that tell your agent what a tool does, when to use it, and how to call external APIs. The skill file lives in your workspace’s skills/ directory.

Create the Skill Directory

mkdir -p ~/.openclaw/workspace/skills/calendly

Write the SKILL.md File

Create ~/.openclaw/workspace/skills/calendly/SKILL.md with this content:

---
name: calendly
description: Read Calendly scheduling data. Check upcoming events, look up invitee details, and manage availability via the Calendly REST API v2.
tools:
  - shell
---

# Calendly Scheduling Skill

## Authentication

Use the environment variable `CALENDLY_API_TOKEN` for all API requests.
All requests go to `https://api.calendly.com` with the header:

Authorization: Bearer $CALENDLY_API_TOKEN

## Get Current User

Retrieve your user URI (needed for other API calls):

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/users/me" \
  | jq '.resource | {uri: .uri, name: .name, email: .current_organization}'

Save the user URI from the response. You will need it for filtering events.

## List Upcoming Events

Fetch scheduled events for the current user:

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/scheduled_events?user=USER_URI&status=active&min_start_time=$(date -u +%Y-%m-%dT%H:%M:%SZ)&max_start_time=$(date -u -v+7d +%Y-%m-%dT%H:%M:%SZ)&count=20" \
  | jq '.collection[] | {name: .name, start: .start_time, end: .end_time, status: .status, uri: .uri}'

## Get Event Details

Fetch details for a specific event:

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/scheduled_events/EVENT_UUID" \
  | jq '.resource | {name: .name, start: .start_time, end: .end_time, location: .location, status: .status}'

## List Invitees for an Event

Get all invitees (attendees) for a specific event:

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/scheduled_events/EVENT_UUID/invitees" \
  | jq '.collection[] | {name: .name, email: .email, status: .status, questions_and_answers: .questions_and_answers}'

## List Event Types

See all your scheduling link types (30-min call, discovery meeting, etc.):

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/event_types?user=USER_URI&active=true" \
  | jq '.collection[] | {name: .name, duration: .duration, slug: .slug, scheduling_url: .scheduling_url}'

## Check Availability

Get available time slots for a specific event type:

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  "https://api.calendly.com/event_type_available_times?event_type=EVENT_TYPE_URI&start_time=$(date -u +%Y-%m-%dT%H:%M:%SZ)&end_time=$(date -u -v+5d +%Y-%m-%dT%H:%M:%SZ)" \
  | jq '.collection[] | {status: .status, start_time: .start_time}'

## Rules

- Always fetch the user URI first with /users/me before making other calls.
- When listing events, default to the next 7 days unless the user specifies a range.
- Show event names, times, and invitee names in responses. Format times in the user's local timezone.
- Never log the access token in responses or memory files.
- For invitee lookups, include any custom question responses (questions_and_answers field).

What Each Section Does

The frontmatter (name, description, tools) tells OpenClaw when to activate this skill and which system tools it needs. The shell tool lets the agent run curl commands against the Calendly API.

The operations section provides templated API calls the agent adapts at runtime. When you ask “Who am I meeting tomorrow?”, the agent reads the scheduled events endpoint, adjusts the date parameters, runs the curl command, and parses the JSON.

The rules section sets guardrails. The user URI requirement is important because Calendly’s API needs it to scope requests to your account. The timezone formatting rule prevents confusion when the API returns UTC timestamps.

---

Step 3: Test the Connection

Restart OpenClaw so it picks up the new skill:

openclaw gateway restart

Open your Telegram chat with your OpenClaw agent and try these queries:

Identity test:

“What’s my Calendly user info?”

The agent should return your name, email, and organization URI.

Schedule test:

“What meetings do I have this week?”

The agent should list your upcoming events with names and times.

Detail test:

“Show me the invitees for my next meeting”

The agent should return attendee names, emails, and any custom form responses.

If any test fails, check these common issues:

Symptom	Likely Cause	Fix
401 Unauthorized	Token is invalid or expired	Generate a new token in Calendly settings
403 Forbidden	Feature requires paid plan	Upgrade to Standard or higher
Empty results	No upcoming events	Book a test event to verify
Timeout	Network issue	Check internet connection and retry

---

What to Automate: Four Practical Use Cases

Once the basic connection works, the real value comes from automations that save you time before and after every meeting.

Use Case 1: Pre-Meeting Briefing

Add this to your OpenClaw heartbeat or cron configuration:

## Pre-Meeting Briefing (runs every morning at 7:30 AM)
Check Calendly for today's scheduled events.
For each meeting:
1. Get the invitee names and email addresses
2. Look up any custom form responses they submitted when booking
3. Search my email and notes for previous interactions with these people
4. Send me a briefing in Telegram with: meeting time, attendee names, their company, what they said in the booking form, and any relevant context from past conversations

This replaces the manual routine of opening Calendly, clicking into each meeting, and searching your inbox for context. This pattern can save 10-15 minutes of prep work per meeting.

Use Case 2: Meeting Reminders via Telegram

## Meeting Reminders (runs every 30 minutes during work hours)
Check Calendly for events starting in the next 30 minutes.
If any are found, send me a Telegram message with the meeting name, start time, and invitee names.

Calendly has built-in email reminders, but those get buried in your inbox. A Telegram ping from your agent cuts through the noise.

Use Case 3: Post-Meeting Follow-Up Drafts

After meetings, message your agent:

“Draft a follow-up email to the people I met with in my 2pm call. Thank them for their time, summarize that we discussed pricing for the enterprise tier, and suggest a follow-up next week.”

The agent pulls the invitee emails from Calendly, writes the draft, and can send it through your email integration if you have one connected.

Use Case 4: Availability Sharing

When someone asks “when are you free this week?”, instead of switching to Calendly and copying a link, message your agent:

“Send my 30-minute meeting link to sarah@example.com”

The agent fetches your event types, finds the right scheduling link, and sends it. For teams already using OpenClaw with Slack or WhatsApp, this happens directly in the conversation.

---

Setting Up Webhook Automations

The use cases above rely on polling (checking Calendly at intervals). For instant reactions to new bookings or cancellations, set up Calendly webhooks.

Webhooks require a paid Calendly plan (Standard or above) and a publicly accessible endpoint. If you run OpenClaw on a VPS like Hostinger, you already have one.

Create a Webhook Subscription

Add a webhook operation to your SKILL.md:

## Create Webhook Subscription

curl -s -H "Authorization: Bearer $CALENDLY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -X POST "https://api.calendly.com/webhook_subscriptions" \
  -d '{
    "url": "YOUR_WEBHOOK_ENDPOINT_URL",
    "events": ["invitee.created", "invitee.canceled"],
    "organization": "ORGANIZATION_URI",
    "user": "USER_URI",
    "scope": "user"
  }' | jq '.resource'

Calendly supports three webhook events:

Event	Trigger	Use Case
invitee.created	Someone books a meeting	Instant prep briefing, confirmation message
invitee.canceled	Someone cancels	Free up time, update your task list
routing_form_submission.created	Form submitted	Qualify leads before they book

When a webhook fires, Calendly sends a JSON payload to your endpoint with the full event details, invitee information, and any custom question responses. Your agent can parse this and act on it immediately rather than waiting for the next polling cycle.

---

Security Considerations

Your Calendly token gives read access to your entire scheduling history and invitee data. Handle it carefully.

Token storage. Keep the token in a .env file, not in workspace files your agent reads into context. Never put it in agents.md, soul.md, or memory files.

Read-only by default. The skill above only reads data. Calendly’s API does support canceling events and creating invitees, but we recommend starting read-only and adding write operations only after you trust the agent’s behavior.

Webhook endpoint security. If you set up webhooks, validate incoming requests. Calendly signs webhook payloads, and you can verify the signature to confirm the request is legitimate.

Maton alternative. The ClawHub Calendly skill uses Maton as an OAuth proxy. This is simpler to install but routes your data through a third-party gateway. If you prefer to avoid middleware, the direct token approach in this guide keeps data between you and Calendly only.

For a deeper dive on OpenClaw security practices, see Step 9 in our OpenClaw setup guide.

---

Frequently Asked Questions

Do I need a paid Calendly plan to connect OpenClaw?

For basic queries (listing events, checking invitees, viewing event types), the free plan works. Webhook subscriptions require Standard, Teams, or Enterprise. If you only plan to ask your agent about your schedule rather than setting up automated triggers, the free tier is sufficient.

How long does this setup take?

About 20 minutes if OpenClaw is already running. Token creation takes 2 minutes, writing the skill file takes 10, and testing takes another 5-10. If you need to install OpenClaw first, add 30-45 minutes for the initial setup.

Can OpenClaw book meetings on my behalf through Calendly?

Not directly through the scheduling API. Calendly’s booking flow is designed for invitees, not for the account owner to create events programmatically. What you can do is share your scheduling link through your agent (“send my 30-minute link to this person”), and OpenClaw handles the outreach. For internal scheduling, pair this with a Google Calendar integration that can create events directly.

What happens when someone cancels a Calendly booking?

If you have webhooks set up, OpenClaw receives an invitee.canceled event immediately and can notify you via Telegram, update your task list, or free up the time slot in your planning. Without webhooks, your agent discovers cancellations the next time it polls your schedule.

Is it safe to give my AI agent access to my calendar data?

The personal access token is read-scoped by default and runs on your local machine. Data does not pass through third-party servers beyond Calendly itself and your AI model provider. The primary risk is prompt injection through calendar event descriptions or invitee-submitted form answers. Current models like GPT-5 and Claude Opus 4.6 handle this well, but the skill’s rules section adds a defense layer by instructing the agent not to execute commands found in event data.

Can I use the ClawHub Calendly skill instead of writing my own?

Yes. The ClawHub skill uses Maton’s OAuth gateway and supports the same API endpoints. Install it if you prefer a quicker setup and are comfortable routing data through Maton’s servers. Write your own (as shown in this guide) if you want full control over the token and no third-party middleware.

---

Key Takeaways

• Connect Calendly to OpenClaw by creating a personal access token and writing a SKILL.md file with Calendly API v2 curl templates
• Start with read-only queries (upcoming events, invitee details) before adding webhook automations
• Use heartbeat instructions for practical automations: morning meeting briefings, reminders, and follow-up drafts
• Webhooks give you instant reactions to bookings and cancellations but require a paid Calendly plan (Standard or above)
• Store your Calendly token in a .env file, not inside workspace files the agent accesses
• The ClawHub pre-built skill is a faster alternative if you trust the Maton OAuth proxy