// connections

Calendly

Read and book Calendly meetings, check availability, create booking links, and manage event types, contacts and webhooks. Connect with OAuth or a personal access token.

22 mcp tools52 operationsvendor sync

rest: https://api.superagnt.com/v1/connections/calendly plus the vendor's own path, with your superagnt_ API key as Authorization: Bearer.
mcp: Tools named connection_calendly_* on https://mcp.superagnt.com/mcp, served once the account is connected.
billing: Calendly bills your own account. Calls cost no superagnt_ data credits.
rate limit: 8 requests a second, 500 a minute: the vendor's ceiling as the registry records it, for sizing bursts. Your plan's own limit is on Connections.
vendor docs: https://developer.calendly.com/api-docs
sync: Can copy 4 tables into your workspace database and keep them fresh: the tables.

The Calendly connection lets an agent work the Calendly account you schedule with. It reads booked meetings and their invitees (booking answers, UTM tracking, cancellations, reschedules and no-shows), checks busy times and an event type's open times, books meetings, creates single-use and customized booking links, manages event types and contacts, reads availability schedules, routing forms and the organization's members, and subscribes a URL to Calendly's webhooks.

start with the connected user

Calendly identifies everything by a full URI, such as https://api.calendly.com/users/<uuid>. Call connection_calendly_users_read with action me first: it returns your user URI (resource.uri) and your organization URI (resource.current_organization), which most other tools take. A tool or path that takes a uuid wants the last segment of a URI.

Setup

Connect with Calendly

Start the install. In the superagnt app open Integrations, pick Calendly and click Connect with Calendly.
Approve the scopes. superagnt_ asks for users:read, organizations:read, groups:read, event_types:write, scheduled_events:write, availability:read, routing_forms:read, contacts:write, webhooks:write, scheduling_links:write, shares:write and locations:read (a :write scope includes its :read).
Call Calendly. Access tokens last two hours, and superagnt_ refreshes them for you.

Calendly lets you decline some scopes at install. A tool that needs a declined scope gets a 403 from Calendly.

Paste a personal access token

To use a token instead, click Use API key instead. Where Connect with Calendly is not offered, the dialog asks for the token straight away.

Create a token. In Calendly open Integrations → API & Webhooks and generate a personal access token. Pick its scopes when you create it: it reaches nothing else. Use the list above, and add organizations:write to invite or remove organization members, or activity_log:read for the Enterprise activity log.
Paste it. Paste the token on the Calendly connection in the superagnt app.

Calendly revokes a personal access token when its user changes login email, password or login method. Paste a new one after that. When a workspace has both an OAuth install and a pasted token, calls use the OAuth install.

connect as an owner or admin

Every Calendly token belongs to one user. An organization owner or admin can read every member's meetings (pass organization to connection_calendly_scheduled_events_read action list) and create organization-wide webhooks. A member's connection reads only their own meetings, or a group's when they administer it.

Plans and limits

Booking a meeting and subscribing to webhooks need a Calendly Standard plan or above. On Free, Calendly answers 403.
Routing forms need a Teams or Enterprise plan, and the activity log needs Enterprise.
Calendly allows 500 requests per user per minute on paid plans and 50 on Free. Booking is capped at 10 a minute, 50 an hour and 100 a day.
Paged lists take count (up to 100, or 1,000 for the activity log) and page_token: pass each response's pagination.next_page_token back for the next page.
Busy times (7 days at most) and open times (31 days at most) are windows, not pages, and may not start in the past.

Things to know

Meetings filter by start time only. There is no changed-since filter, so a cancellation or no-show on a meeting outside the window you list does not show up. Rescan the window you care about, or subscribe to webhooks.
Calendly disables a webhook subscription after 24 hours of failed deliveries, and it has to be created again. connection_calendly_webhooks_read action list shows each subscription's state. Creating a subscription that already exists answers 409.
routing_form_submission.created works only on organization-scope subscriptions and meeting_recap.* only on user-scope ones, so subscribe to those separately. meeting_recap.* also needs meeting_recaps:read, which the OAuth connection does not request.
The API creates and updates only one-on-one event types, and cannot delete them: retire one with active: false.
Updating a contact replaces its whole emails and phone_numbers lists. Read the contact first and send every entry you want kept.
There is no reschedule call. Cancel and book again, or send the invitee their reschedule_url.
Inviting and removing organization members and revoking invitations need an org owner or admin and organizations:write, and the activity log needs activity_log:read. The OAuth connection requests neither scope, so both need a personal access token created with it.
The connection does not cover data-compliance deletion, outgoing communications, meeting recaps, availability edits, one-off event types or Calendly's OAuth endpoints.

Permissions

These defaults decide whether a superagnt_ agent runs a call or waits for a person (Permissions). Reads run without asking. Creating and updating event types and contacts, creating booking links and marking no-shows also run by default. Inviting someone to the organization and creating a webhook subscription ask by default. Booking a meeting, cancelling one, removing a member, revoking an invitation, removing a no-show mark and every delete always ask a person first.

Examples

Who is connected

who is connectedbash

curl "https://api.superagnt.com/v1/connections/calendly/users/me" \
  -H "Authorization: Bearer $AGNTDATA_API_KEY"

This week's meetings

list active meetings in a windowbash

curl "https://api.superagnt.com/v1/connections/calendly/scheduled_events?user=https://api.calendly.com/users/AAAAAAAAAAAAAAAA&status=active&min_start_time=2026-10-12T00:00:00Z&max_start_time=2026-10-19T00:00:00Z&sort=start_time:asc" \
  -H "Authorization: Bearer $AGNTDATA_API_KEY"

Open times for an event type

list open start timesbash

curl "https://api.superagnt.com/v1/connections/calendly/event_type_available_times?event_type=https://api.calendly.com/event_types/BBBBBBBBBBBBBBBB&start_time=2026-11-02T00:00:00Z&end_time=2026-11-09T00:00:00Z" \
  -H "Authorization: Bearer $AGNTDATA_API_KEY"

A single-use booking link

create a single-use linkbash

curl -X POST "https://api.superagnt.com/v1/connections/calendly/scheduling_links" \
  -H "Authorization: Bearer $AGNTDATA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "max_event_count": "1",
    "owner": "https://api.calendly.com/event_types/BBBBBBBBBBBBBBBB",
    "owner_type": "EventType"
  }'

The response carries the booking_url. Nothing is sent, so share the link yourself.

Receiving Calendly webhooks

Create a subscription with connection_calendly_webhooks_write (action create) for the events you care about, such as invitee.created, invitee.canceled, invitee_no_show.created, routing_form_submission.created or contact.created, and point it at a superagnt_ inbound webhook endpoint to trigger an agent. Calendly signs deliveries with its own Calendly-Webhook-Signature header, which an inbound endpoint does not check, so leave the endpoint's signature verification off and keep its URL secret. A receiver of your own can set signing_key on the subscription and verify that header.

Sync

A Calendly sync copies your meetings, their invitees, your event types and the organization's members into tables in your workspace database and keeps them fresh, so agents read local tables instead of calling Calendly on every run. Turn it on from the Sync panel on the Calendly connection page in the superagnt app. The panel previews the rows and webhook events against your plan before anything is created. How syncs work in general: Vendor sync.

How updates arrive. The sync registers one Calendly webhook subscription of its own for invitees booked and canceled and for no-show marks added or removed, and checks Calendly's signature on every delivery. A delivery makes the sync re-read that meeting and its invitees, so a late or repeated delivery never overwrites newer state. Polling also re-reads recent and upcoming meetings on every pass, and the last 30 days once a day. Because Calendly has no changed-since filter, a change to an older meeting that sent no webhook shows up only when a rescan covers it.

Plans and scope.

An owner or admin token syncs the whole organization, with event types and hosts as filters. A member's token, or one without organizations:read, syncs only that member's meetings, and the preview says whose.
Calendly webhooks need the Standard plan or above. On Free, or with a token that lacks webhooks:write, the sync says so and keeps the tables current by polling.
A personal access token needs users:read, organizations:read, event_types:read, scheduled_events:read and webhooks:write for the full sync. Without event_types:read or scheduled_events:read, only the tables that need that scope pause, with a note naming it: reconnect with a token that includes it, or turn those tables off.
On an OAuth connection the sync can fall back to polling instead of receiving webhooks. The Sync panel says so when it does, and a personal access token connection receives them.
The sync's calls share Calendly's per-user rate limit with your agents' Calendly tool calls, so it paces itself to stay under it.

08// sync tables

What a Calendly sync copies

A sync copies these tables into your workspace database and keeps them fresh, so an agent reads local rows instead of calling Calendly on every run. Turn tables on and off from the Sync panel on the connection. Every table also carries _raw, _hash, _synced_at and _deleted_at. How syncs work: Vendor sync.

beta

The Calendly sync is built from Calendly's API documentation and has not been verified against a live Calendly account yet. A field the documentation does not show stays in each row's _raw column.

Table	What it holds	Default
`calendly_scheduled_events` Meetings	Every booked meeting that starts inside the history window, plus all upcoming ones, kept current by invitee webhooks and a rolling re-read of recent and upcoming meetings (the last 30 days once a day). Calendly reports no edit times, so a change to an older meeting shows up only when a rescan covers it.	on
`calendly_invitees` Invitees	One row per invitee of each synced meeting, with their answers, UTM tracking, cancellation, no-show and reschedule links. Read with their meeting.	on
`calendly_event_types` Event types	The bookable event types, re-read every hour; ones Calendly no longer returns are marked deleted.	on
`calendly_users` Members	The organization's members and their roles, re-read daily (on a member's token, only that member).	on

09// mcp tools

22 tools, one per resource and risk

MCP servers and agents on the grouped surface list Calendly as these tools. Each takes an action, and the ones that work across record types an object. Every operation also keeps its own per-operation name, in the next table, which works on every server. How grouping works: Grouped tools.

Tool	Risk	Actions
`connection_calendly_users_read` Read Calendly users Get the Calendly user this connection acts as, or another user by UUID. Start with action me: most Calendly tools take the user or organization URI it returns, and every Calendly reference is a full URI.	read	meget
`connection_calendly_organization_read` Read the Calendly organization Get the organization's name, plan and stage. Its admin audit trail (Enterprise only) lists under its own name, connection_calendly_list_activity_log_entries.	read	get
`connection_calendly_members_read` Read Calendly organization members List an organization's members with their roles, or one user's membership, get one membership, or list and get the invitations sent to join the organization.	read	listgetinvitationsinvitation
`connection_calendly_members_write` Invite someone to a Calendly organization Email an invitation to join the organization; accepting it takes a paid seat. Needs an org admin or owner, and a personal access token with organizations:write, which the Calendly OAuth connection does not request.	write	invite
`connection_calendly_members_delete` Remove Calendly members and invitations Remove a person from the organization, which frees their seat and stops the user-scope webhooks they created (their past events stay visible to admins), or revoke a pending invitation so its emailed link stops working. Needs an org admin or owner, and a personal access token with organizations:write. The organization owner cannot be removed.	destructive	removerevoke_invitation
`connection_calendly_groups_read` Read Calendly groups List the organization's groups (departments or teams on Teams and Enterprise plans) or get one, and list or get who belongs to or administers each group.	read	listgetrelationshipsrelationship
`connection_calendly_event_types_read` Read Calendly event types List the event types (the bookable meeting templates) of an organization or one user, get one with its duration, locations and booking questions, or list its hosts.	read	listgethosts
`connection_calendly_event_types_write` Create and edit Calendly event types Create a one-on-one event type, or change one's name, duration, description, color, locale, locations or active state. Only solo event types can be created or changed, and the API cannot delete one: set active to false to retire it.	write	createupdate
`connection_calendly_availability_read` Read Calendly availability Find an event type's open start times to pick one before booking, read a user's busy times, availability schedules and meeting locations, or the availability rules an event type uses. A time window may not start in the past.	read	available_timesbusy_timesschedulesscheduleevent_type_scheduleslocations
`connection_calendly_scheduled_events_read` Read Calendly meetings List booked meetings of a user, an organization or a group by status, invitee email and start-time window, get one, list or get its invitees, or read a no-show mark. There is no updated-since filter: a change to a meeting outside the window does not show, so rescan the window you care about.	read	listgetinviteesinviteeno_show
`connection_calendly_scheduled_events_write` Book a Calendly meeting Book a meeting on an event type for an invitee at a start time (pick one with connection_calendly_availability_read action available_times). Calendly sends the confirmation email and calendar invites and runs the event type's workflows, as a booking on its own page would, so get the user's sign-off first. Needs a Standard plan or above; at most 10 bookings a minute, 50 an hour and 100 a day.	write	book
`connection_calendly_scheduled_events_delete` Cancel a Calendly meeting Cancel a meeting for everyone on it: Calendly emails every invitee and host a cancellation and removes it from their calendars. It cannot be undone, and the API has no reschedule: send the invitee's reschedule_url instead.	destructive	cancel
`connection_calendly_no_shows_write` Mark a Calendly no-show Mark an invitee as a no-show on a meeting. Nothing is sent. Undo it with connection_calendly_no_shows_delete.	write	mark
`connection_calendly_no_shows_delete` Remove a Calendly no-show mark Remove a no-show mark, so the invitee counts as having attended.	destructive	remove
`connection_calendly_booking_links_write` Create Calendly booking links Create a booking link for an event type that works for one booking, or a customized one-off copy of a one-on-one event type for one invitee (a different duration, date range, availability or location) with its single-use booking links. Nothing is sent: share the returned link yourself. An unused single-use link expires after 90 days.	write	single_usecustom
`connection_calendly_routing_forms_read` Read Calendly routing forms List the organization's routing forms (Teams and Enterprise plans) or get one with its questions, and list or get a form's submissions, including those that never booked.	read	listgetsubmissionssubmission
`connection_calendly_webhooks_read` Read Calendly webhooks List webhook subscriptions with their state, get one, or get a sample payload for an event to build a handler. Calendly disables a subscription after 24 hours of failed deliveries, so check state.	read	listgetsample
`connection_calendly_webhooks_write` Subscribe a URL to Calendly events Subscribe a URL to Calendly events at organization, user or group scope. Needs a Standard plan or above. A 409 means the same subscription already exists, and a disabled one must be created again. Set signing_key to verify the Calendly-Webhook-Signature header.	write	create
`connection_calendly_webhooks_delete` Delete a Calendly webhook Delete a webhook subscription; Calendly stops sending its events.	destructive	delete
`connection_calendly_contacts_read` Read Calendly contacts List contacts filtered by email, phone, timezone, location, name, job title or company (updated_at:desc finds recent changes), get one, or list the custom fields contacts can carry.	read	listgetcustom_fields
`connection_calendly_contacts_write` Create and update Calendly contacts Create a contact or update one. On update, emails and phone_numbers replace the whole list, so read the contact first and send every entry to keep. Custom field values are keyed by definition uuid (connection_calendly_contacts_read action custom_fields), and one unknown uuid or wrongly typed value refuses the whole request.	write	createupdate
`connection_calendly_contacts_delete` Delete a Calendly contact Permanently delete a contact.	destructive	delete

10// operations

All 52 operations

Each operation is a REST path under https://api.superagnt.com/v1/connections/calendly and an MCP tool. The per-operation tool name is the one permissions, approvals and usage records use.

Operation	MCP tool
GET`/users/me` Get the connected user	`connection_calendly_get_current_user`grouped: `connection_calendly_users_read`, action `me`
GET`/users/{uuid}` Get a user	`connection_calendly_get_user`grouped: `connection_calendly_users_read`, action `get`
GET`/organizations/{uuid}` Get the organization	`connection_calendly_get_organization`grouped: `connection_calendly_organization_read`, action `get`
GET`/organization_memberships` List organization members	`connection_calendly_list_organization_memberships`grouped: `connection_calendly_members_read`, action `list`
GET`/organization_memberships/{uuid}` Get an organization membership	`connection_calendly_get_organization_membership`grouped: `connection_calendly_members_read`, action `get`
DELETE`/organization_memberships/{uuid}` Remove a member from the organization	`connection_calendly_remove_organization_member`grouped: `connection_calendly_members_delete`, action `remove`
GET`/organizations/{uuid}/invitations` List organization invitations	`connection_calendly_list_organization_invitations`grouped: `connection_calendly_members_read`, action `invitations`
POST`/organizations/{uuid}/invitations` Invite someone to the organization	`connection_calendly_invite_organization_member`grouped: `connection_calendly_members_write`, action `invite`
GET`/organizations/{org_uuid}/invitations/{uuid}` Get an organization invitation	`connection_calendly_get_organization_invitation`grouped: `connection_calendly_members_read`, action `invitation`
DELETE`/organizations/{org_uuid}/invitations/{uuid}` Revoke an organization invitation	`connection_calendly_revoke_organization_invitation`grouped: `connection_calendly_members_delete`, action `revoke_invitation`
GET`/groups` List groups	`connection_calendly_list_groups`grouped: `connection_calendly_groups_read`, action `list`
GET`/groups/{uuid}` Get a group	`connection_calendly_get_group`grouped: `connection_calendly_groups_read`, action `get`
GET`/group_relationships` List group relationships	`connection_calendly_list_group_relationships`grouped: `connection_calendly_groups_read`, action `relationships`
GET`/group_relationships/{uuid}` Get a group relationship	`connection_calendly_get_group_relationship`grouped: `connection_calendly_groups_read`, action `relationship`
GET`/event_types` List event types	`connection_calendly_list_event_types`grouped: `connection_calendly_event_types_read`, action `list`
POST`/event_types` Create an event type	`connection_calendly_create_event_type`grouped: `connection_calendly_event_types_write`, action `create`
GET`/event_types/{uuid}` Get an event type	`connection_calendly_get_event_type`grouped: `connection_calendly_event_types_read`, action `get`
PATCH`/event_types/{uuid}` Update an event type	`connection_calendly_update_event_type`grouped: `connection_calendly_event_types_write`, action `update`
GET`/event_type_memberships` List an event type's hosts	`connection_calendly_list_event_type_hosts`grouped: `connection_calendly_event_types_read`, action `hosts`
GET`/user_availability_schedules` List a user's availability schedules	`connection_calendly_list_user_availability_schedules`grouped: `connection_calendly_availability_read`, action `schedules`
GET`/user_availability_schedules/{uuid}` Get an availability schedule	`connection_calendly_get_user_availability_schedule`grouped: `connection_calendly_availability_read`, action `schedule`
GET`/event_type_availability_schedules` Get an event type's availability	`connection_calendly_list_event_type_availability_schedules`grouped: `connection_calendly_availability_read`, action `event_type_schedules`
GET`/user_busy_times` List a user's busy times	`connection_calendly_list_user_busy_times`grouped: `connection_calendly_availability_read`, action `busy_times`
GET`/event_type_available_times` List open times for an event type	`connection_calendly_list_event_type_available_times`grouped: `connection_calendly_availability_read`, action `available_times`
GET`/locations` List a user's meeting locations	`connection_calendly_list_user_locations`grouped: `connection_calendly_availability_read`, action `locations`
GET`/scheduled_events` List scheduled meetings	`connection_calendly_list_scheduled_events`grouped: `connection_calendly_scheduled_events_read`, action `list`
GET`/scheduled_events/{uuid}` Get a scheduled meeting	`connection_calendly_get_scheduled_event`grouped: `connection_calendly_scheduled_events_read`, action `get`
POST`/scheduled_events/{uuid}/cancellation` Cancel a meeting	`connection_calendly_cancel_scheduled_event`grouped: `connection_calendly_scheduled_events_delete`, action `cancel`
GET`/scheduled_events/{uuid}/invitees` List a meeting's invitees	`connection_calendly_list_event_invitees`grouped: `connection_calendly_scheduled_events_read`, action `invitees`
GET`/scheduled_events/{event_uuid}/invitees/{invitee_uuid}` Get an invitee	`connection_calendly_get_event_invitee`grouped: `connection_calendly_scheduled_events_read`, action `invitee`
POST`/invitees` Book a meeting	`connection_calendly_book_meeting`grouped: `connection_calendly_scheduled_events_write`, action `book`
POST`/invitee_no_shows` Mark an invitee as a no-show	`connection_calendly_mark_invitee_no_show`grouped: `connection_calendly_no_shows_write`, action `mark`
GET`/invitee_no_shows/{uuid}` Get a no-show mark	`connection_calendly_get_invitee_no_show`grouped: `connection_calendly_scheduled_events_read`, action `no_show`
DELETE`/invitee_no_shows/{uuid}` Remove a no-show mark	`connection_calendly_delete_invitee_no_show`grouped: `connection_calendly_no_shows_delete`, action `remove`
POST`/scheduling_links` Create a single-use booking link	`connection_calendly_create_scheduling_link`grouped: `connection_calendly_booking_links_write`, action `single_use`
POST`/shares` Create a customized one-off link	`connection_calendly_create_share`grouped: `connection_calendly_booking_links_write`, action `custom`
GET`/routing_forms` List routing forms	`connection_calendly_list_routing_forms`grouped: `connection_calendly_routing_forms_read`, action `list`
GET`/routing_forms/{uuid}` Get a routing form	`connection_calendly_get_routing_form`grouped: `connection_calendly_routing_forms_read`, action `get`
GET`/routing_form_submissions` List routing form submissions	`connection_calendly_list_routing_form_submissions`grouped: `connection_calendly_routing_forms_read`, action `submissions`
GET`/routing_form_submissions/{uuid}` Get a routing form submission	`connection_calendly_get_routing_form_submission`grouped: `connection_calendly_routing_forms_read`, action `submission`
GET`/webhook_subscriptions` List webhook subscriptions	`connection_calendly_list_webhook_subscriptions`grouped: `connection_calendly_webhooks_read`, action `list`
POST`/webhook_subscriptions` Subscribe a URL to Calendly events	`connection_calendly_create_webhook_subscription`grouped: `connection_calendly_webhooks_write`, action `create`
GET`/webhook_subscriptions/{uuid}` Get a webhook subscription	`connection_calendly_get_webhook_subscription`grouped: `connection_calendly_webhooks_read`, action `get`
DELETE`/webhook_subscriptions/{uuid}` Delete a webhook subscription	`connection_calendly_delete_webhook_subscription`grouped: `connection_calendly_webhooks_delete`, action `delete`
GET`/sample_webhook_data` Get a sample webhook payload	`connection_calendly_get_sample_webhook_data`grouped: `connection_calendly_webhooks_read`, action `sample`
GET`/contacts` List contacts	`connection_calendly_list_contacts`grouped: `connection_calendly_contacts_read`, action `list`
POST`/contacts` Create a contact	`connection_calendly_create_contact`grouped: `connection_calendly_contacts_write`, action `create`
GET`/contacts/custom_field_definitions` List contact custom fields	`connection_calendly_list_contact_custom_field_definitions`grouped: `connection_calendly_contacts_read`, action `custom_fields`
GET`/contacts/{uuid}` Get a contact	`connection_calendly_get_contact`grouped: `connection_calendly_contacts_read`, action `get`
PATCH`/contacts/{uuid}` Update a contact	`connection_calendly_update_contact`grouped: `connection_calendly_contacts_write`, action `update`
DELETE`/contacts/{uuid}` Delete a contact	`connection_calendly_delete_contact`grouped: `connection_calendly_contacts_delete`, action `delete`
GET`/activity_log_entries` List activity log entries	`connection_calendly_list_activity_log_entries`grouped servers list it under this name