How to Use n8n with ._Template 11 Calendly Cancelled Reschedule

When a prospect cancels a Calendly meeting, most teams do nothing. The event disappears from the calendar, the lead goes cold, and nobody follows up until someone notices the gap three days later. That silent drop-off is one of the most expensive leaks in a sales or onboarding funnel — you already earned the booking, and then you let it evaporate. This guide shows you how to close that leak with n8n by turning every Calendly cancellation into an automatic, personalized reschedule offer, using the Calendly Cancelled → Reschedule template.

The problem: cancellations are dead ends by default

Calendly is excellent at booking meetings and terrible at recovering them. When an invitee cancels, Calendly sends a bland confirmation of the cancellation and then stops. There is no built-in nudge, no "want to find another time?" flow, no logging of who bailed and why. For a busy founder or ops team, this creates three concrete problems:

First, lost pipeline. A cancelled demo is not a lost lead — most cancellations are scheduling conflicts, not rejections. But without an immediate reschedule prompt, the intent fades within hours. Second, no visibility. Cancellations rarely land anywhere your team actually watches, so you never see the pattern (e.g., 40% of Monday-morning slots get cancelled). Third, manual recovery doesn't scale. If you're personally emailing every no-show, you're doing $12/hour work as the most expensive person in the company.

The fix is not another SaaS subscription. It's a small, reliable automation that listens for the cancellation event and responds within seconds — while the invitee is still thinking about you.

The solution: an event-driven reschedule loop in n8n

The template works as a webhook-triggered workflow. Calendly fires an invitee.canceled event; n8n catches it, extracts the invitee's details, sends a friendly reschedule email with a fresh booking link, and logs the cancellation to a sheet or CRM for later analysis. The whole loop runs in under two seconds and requires zero human intervention.

The core node chain looks like this:

Webhook (Trigger) → Filter (event type) → Set (map fields) → Send Email / Gmail → Google Sheets or HTTP Request (CRM log)

Because it's event-driven rather than polling, you're not burning executions checking Calendly every five minutes. It only runs when something actually cancels, which keeps it cheap even on n8n's lower tiers or a self-hosted instance.

Step-by-step setup in n8n

1. Create the Webhook trigger. Add a Webhook node, set the HTTP method to POST, and copy the production URL. Give it a clear path like calendly-cancelled. This URL is what you'll register with Calendly.

2. Register the webhook in Calendly. Calendly's webhook subscriptions are created via their API, not the dashboard UI. Add an HTTP Request node (run it once manually) that POSTs to https://api.calendly.com/webhook_subscriptions with a Bearer token from your Calendly integrations settings. In the body, set url to your n8n webhook, events to ["invitee.canceled"], and scope to user or organization. Once registered, every cancellation will hit your workflow automatically.

3. Filter for the right event. Even though you subscribed to only one event, add an IF or Filter node that checks {{ $json.body.event }} equals invitee.canceled. This protects you from test pings and future event types you might add to the same webhook.

4. Map the fields with a Set node. Calendly's payload nests the useful data under payload. Use a Set (Edit Fields) node to pull out clean variables:

name → {{ $json.body.payload.name }}
email → {{ $json.body.payload.email }}
event_type → {{ $json.body.payload.scheduled_event.name }}
cancel_reason → {{ $json.body.payload.cancellation.reason }}

This makes every downstream node readable and stops you from writing brittle deep-path expressions five times.

5. Send the reschedule email. Use the Gmail node (OAuth2) or the generic Send Email (SMTP) node. Keep the copy short and warm — this is a recovery touch, not a newsletter. Reference the specific event by name using {{ $node["Set"].json.event_type }}, and include your evergreen Calendly booking link so they can grab a new slot in one click. A subject like "No problem — grab another time for {{ $json.event_type }}?" outperforms generic "We missed you" lines because it acknowledges the cancellation without guilt.

6. Log the cancellation. Add a Google Sheets (Append Row) node or an HTTP Request to your CRM. Store name, email, event type, reason, and timestamp ({{ $now }}). This turns a one-off recovery into a data asset: within a month you'll see which event types and time slots cancel most, and you can fix the root cause.

7. Add a delayed second touch (optional). Chain a Wait node set to 24–48 hours, followed by an IF node that checks whether the person rebooked. If your CRM or a lookup shows no new booking, fire a second, softer email. This two-step cadence typically recovers 20–35% of cancellations versus around 8% for a single email.

Benefits: what this actually moves

Recovered revenue with zero added headcount. If you book 100 meetings a month and 15 cancel, recovering even a third of them is five extra qualified conversations you were otherwise throwing away — every single month, on autopilot.

Speed that humans can't match. The reschedule offer lands seconds after the cancellation, when intent is highest. No human checks Calendly at 11pm on a Sunday; this workflow does.

A feedback loop on your funnel. The logging step quietly builds a dataset most teams never have. When you notice that "Discovery Call" cancels at 3x the rate of "Onboarding," you can shorten it, re-time it, or requalify earlier.

Full ownership. Because it's your n8n instance and your Calendly API token, there's no per-seat SaaS tax and no vendor lock-in. Self-hosted, this runs for effectively nothing.

Common pitfalls (and how to avoid them)

Testing against the Test URL, then forgetting to switch. n8n webhooks have separate test and production URLs. If you registered the test URL with Calendly, cancellations will silently do nothing once you close the editor. Always register the production URL and activate the workflow.

Assuming the payload shape. Calendly's invitee.canceled payload nests fields under payload and sometimes wraps everything under body depending on your webhook node settings. Run one real cancellation, inspect the actual JSON in the execution log, and map from what you see — not from documentation memory.

No email authentication. Recovery emails that land in spam recover nothing. If you use the SMTP node, send from a domain with proper SPF and DKIM records. The Gmail OAuth node sidesteps most of this for lower volumes.

Re-triggering on reschedules. A reschedule can itself generate a cancel-then-rebook event pair. Without the Filter node and a check against your log, you can spam someone who already rebooked. Deduplicate on email plus a recent-booking check before sending.

Ignoring rate limits and errors. Wrap the email and CRM nodes so a single failure doesn't kill the run. Set the workflow's error workflow or add a NoOp / error branch, and enable "Retry On Fail" on the HTTP and email nodes. A cancellation you failed to catch is worse than one you never listened for, because you'll assume it's handled.

Set this up once and it runs quietly in the background, turning your funnel's most ignored moment into a second chance — automatically, every time.