Guides
Step-by-step guide to connecting Calendly to Thoughtly so your AI voice agent can check availability, book appointments, and confirm — all during a live phone call.
Last updated
Every lead that fills out a form, calls your main line, or responds to an ad wants one thing: to talk to the right person at the right time. The gap between interest and booked appointment is where most conversion loss happens. A prospect calls in at 7 PM, your team is offline, and by tomorrow morning they have already contacted two competitors.
Connecting Calendly to Thoughtly eliminates that gap. Your AI voiceAI voiceAn artificially generated, natural-sounding voice produced by a TTS model. Thoughtly supports a library of AI voices and brand-specific cloning. agent can check real-time availability, present open slots, book the appointment, and confirm it — all during the same phone call. No hold queues, no "someone will call you back," no manual calendar juggling.
This guide walks through every step: connecting the integration, building the agent flow, handling timezones, and avoiding the mistakes that break booking workflows in production. By the end, you will have an agent that books appointments on Calendly during live calls without any human intervention.
If you are new to Thoughtly's agent builder, read the quick-start guide in the docs before starting. You should be comfortable creating Speak nodes, adding variables, and setting outcomes.
Thoughtly has a native Calendly integration — no Zapier, no webhooks, no API keys to manage manually. The connection uses OAuthOAuthAn authentication standard that lets Thoughtly connect to your CRM or app without storing your password., so Calendly handles authentication directly.
If your organization uses multiple Calendly accounts (for example, separate accounts for different office locations), you can connect more than one. When adding an action to your agent, Thoughtly lets you select which connected account to use.
Before opening the agent builder, map out the conversation flow. A well-structured booking agent follows a predictable path:
Each step maps to a Speak node in Thoughtly's agent builder. The key principle: actions run mid-call from Speak nodes, and rule-based outcomes handle branching after each action completes.
Create a Speak node that asks the caller what day works for them. Keep the prompt natural — most callers will say something like "next Tuesday" or "sometime this week" rather than giving an ISO date.
Add two variables on this node:
| Variable | Type | Extraction instruction |
|---|---|---|
| preferred_date | Text | Extract the appointment date the caller states. Output: YYYY-MM-DD. If absent or unclear: return empty. Do not invent values. |
| preferred_timezone | Text | Extract the caller's timezone if stated (e.g., Eastern, Pacific, CST). Output: IANA timezone string. If not stated: return empty. |
Thoughtly's variableVariableA named value the voice agent stores during a conversation — caller name, intent, qualifying answers — and uses to drive routing and post-call actions. extraction runs immediately after the caller's reply, before outcomes evaluate. If the caller says "next Thursday," the extraction instruction resolves it to a concrete date. If they are vague — "sometime next week" — the date extractor resolves to the nearest logical date (typically the next Monday).
Route directly to the next node (Check Availability). If you want to validate that preferred_date is not empty before proceeding, add a rule-based outcome that loops back to this node when the variable is blank, with a re-prompt like "I didn't catch a date — could you tell me what day works?"
Create a new Speak node that runs the Calendly Get Available Times action. This is where the integration does the heavy lifting.
| Field | Value |
|---|---|
| Event Type | Select your Calendly event type (e.g., "30-Minute Consultation") |
| Date | Map to preferred_date variable |
| Timezone | Map to preferred_timezone variable (optional — see timezone handling below) |
The action returns a list of available time slots for the requested date. These slots are available in the action's output, which you can reference in the next node's prompt or variables.
Create another Speak node that reads the returned availability and presents a short list of options. Do not dump every available slot — three options is the sweet spot for voice conversations.
Use a prompt that reads from the availability response:
timeslots: {{response}}
Your task is to provide a few (no more than 3) available time slots from the list, based on the person's request. If the timeslots is empty just say: "I don't have any openings for this day, should I check another one?"
Only provide and talk about information that is available in the timeslots list. If it is empty, do not come up with information; simply let the customer know that you don't have an opening for that date.| Variable | Type | Extraction instruction |
|---|---|---|
| selected_time | Text | Extract the final scheduled datetime the caller intends. Output: YYYY-MM-DDTHH:MM:SS (24h). If the agent proposes a slot and the caller affirms, use that slot. |
Add rule-based outcomes on this node:
selected_time is not empty → proceed to Step 6 (Book the appointment)This loop pattern — check availability, present, re-check if needed — is core to reliable booking agents. Thoughtly's variable extraction overwrites prior values on loop-back, so preferred_date and selected_time stay current as the conversation evolves.
Create a Speak node that runs the Calendly Schedule Appointment action to create the actual calendar event.
| Field | Value |
|---|---|
| Date/Time | Map to selected_time variable |
| Timezone | Map to preferred_timezone (or leave blank for fallback) |
| Invitee Name | Map to caller's name variable (if collected earlier) |
| Invitee Email | Map to caller's email variable (if collected earlier) |
The action creates the Calendly event and returns a booking status. Calendly automatically sends its own confirmation email to the invitee if that setting is enabled in your Calendly event type.
On the same booking node, add rule-based outcomes that check the action's output:
booking_status == "confirmed" → route to a Confirmation nodeUse Message mode for an exact script: "You're all set for [date and time]. You'll receive a confirmation email from Calendly shortly. Is there anything else I can help with?"
If the booking fails (the slot was taken between availability check and booking, or a Calendly API error), the agent should:
If speed is your priority and booking windows are short-term (within a week), Thoughtly supports a second pattern that fetches availability before the call starts using Automations.
available_times).available_times instead of making a live API call.selected_time directly.This pattern eliminates mid-call API latency for availability checks, making conversations feel faster. The tradeoff: prefetched slots can go stale if there is a long delay between the automation run and the call. Best suited for high-volume outbound booking campaigns where calls happen within minutes of the automation trigger.
Timezone mismatches are the most common source of booking errors. Thoughtly and Calendly use a three-level fallback for timezone resolution:
preferred_timezone variable), that value takes priority.America/New_York if nothing else is set.For businesses serving callers across multiple timezones, collect the caller's timezone as a variable and pass it to both the Get Available Times and Schedule Appointment actions. Available times are automatically formatted using the resolved timezone, so the caller hears slots in their local time.
Tip: If your business operates in a single timezone, set the agent timezone in Advanced Settings and skip the variable collection. This keeps the conversation shorter without sacrificing accuracy.
Prompt-based outcomes rely on conversation context to make routing decisions. After a mid-call action, the relevant data (booking status, error codes) exists as internal values, not in the spoken conversation. Use rule-based outcomes that check action output fields like booking_status directly.
If a caller interrupts while a Calendly action is running, it can break the action flow and produce unpredictable results. Disable interruptions on every Speak node that runs a mid-call action.
Calendly can return dozens of slots for a given day. Reading all of them over the phone is a terrible experience. Cap the presentation at three options and offer to check more if none work.
Between the time you check availability and the time you book, someone else might take the slot. Always build an error-handling path that re-checks availability rather than ending the call on a booking failure.
If your agent timezone is not set and you do not collect the caller's timezone, every booking defaults to America/New_York. A caller in LosLOSA loan origination system — the pipeline software lenders use to manage applications. Encompass and Velocify are common; Thoughtly integrates with both. Angeles who books "2 PM" will get a 2 PM Eastern appointment — three hours off. Set your agent timezone at minimum.
If availability checks keep returning empty, the agent should not loop indefinitely. After two or three failed attempts at different dates, offer to transfer to a human or suggest the caller visit the Calendly booking page directly.
Once your Calendly-connected agent is live, track these metrics to evaluate performance:
| Metric | What it measures | Target |
|---|---|---|
| Booking completion rate | Percentage of calls where a Calendly event is successfully created | 60–80% of calls where the caller expresses scheduling intent |
| First-attempt booking rate | Percentage of bookings made without looping back for a different date | 70%+ indicates good prompt design and availability coverage |
| Average time to book | Seconds from first scheduling mention to confirmed booking | Under 90 seconds for straightforward bookings |
| Booking error rate | Percentage of Schedule Appointment actions that fail | Under 5% — higher rates suggest stale slots or integration issues |
| No-show rate | Percentage of booked appointments where the prospect does not show up | Compare against your manual booking no-show rate as a baseline |
| Timezone mismatch rate | Bookings where the confirmed time does not match the caller's intent | Should be near 0% if timezone handling is configured correctly |
Review these in Thoughtly's analytics dashboard alongside Calendly's own event data. If booking completion rates are low, check whether the availability prompt is confusing callers or whether your Calendly event type has enough open slots.
Yes. Calendly Event Types can be configured for round-robin or specific host assignment. When the agent runs Get Available Times, it returns slots based on the event type's availability rules — including multi-host rotation. Thoughtly also supports the Schedule Event By Organization action for organizations that manage scheduling across teams.
The native Calendly integration currently supports booking new appointments and checking availability. For rescheduling or cancellation, include the Calendly event link in a confirmation SMS so the caller can self-manage changes, or route to a human agent via a Transfer node.
Calendly's free plan supports one event type. The integration will work, but you will be limited to a single bookable event type. For teams with multiple appointment types or round-robin scheduling, Calendly Professional or Teams is needed.
Yes. After the booking confirmation node, add an SMS action (or use Thoughtly's built-in SMS capabilities) to send the caller a text with the appointment details and Calendly link. Calendly also sends its own email confirmation if that is enabled in your event type settings.
The booking flow is identical for both. For inbound calls, the agent qualifies the caller first, then transitions into scheduling. For outbound calls, the agent typically re-engages an existing lead and offers to book. The pre-call prefetch pattern (Pattern B) is especially useful for outbound campaigns where you want to present slots immediately without mid-call latency.
Calendly Integration — Thoughtly Docs — Official Calendly integration reference including timezone handling and available actions.
Scheduling Agents — Thoughtly Docs — Complete guide to building scheduling agents with Pattern A and Pattern B approaches.
Agent Actions — Thoughtly Docs — How mid-call actions work, including execution order, error handling, and variable flow.
How to Build an Appointment-Setting AI Agent — Thoughtly Blog — General guide to appointment-setting agents, covering conversation design and qualification before booking.
How to Connect Thoughtly to Zapier for AI Voice Workflows — Thoughtly Blog — Integration guide for connecting Thoughtly to tools without a native integration via Zapier.
Integrations — Thoughtly — Full list of 24+ native integrations across CRMs, schedulers, and communication tools.
Calendly API Documentation — Calendly's developer reference for understanding event types, availability, and scheduling mechanics.