How to Automatically Create ClickUp Tasks and Start a Slack Thread When a Calendly Booking Is Confirmed Using Make.com and Google Calendar

Introduction

A new Calendly booking is great, until someone has to copy the booking details into your project tracker, attach the pre-call brief, invite the right people, and then notify the team in Slack. That manual handoff creates mistakes, missed prep, and poor traceability when bookings are rescheduled or canceled.

This guide shows you an advanced, production-ready Make.com scenario: receive Calendly webhooks, confirm the calendar event exists in Google Calendar, create or update a ClickUp task with the exact booking data and prefilled checklist, and post a threaded Slack message to the right channel. By the end you will have a resilient pattern with idempotency, reschedule handling, and observability suitable for high-volume scheduling.

What you'll know by the end: how the pieces fit, which exact Make.com modules to use, field mappings to copy, and the gotchas to avoid when Calendly fires multiple webhook events for one user action.

What You'll Need

• Calendly account, access to create webhook subscriptions (API v2 personal access token or OAuth). Webhooks: invitee.created, invitee.canceled, invitee.rescheduled.
• Make.com account with connections for Calendly (webhook), Google Calendar, ClickUp, and Slack. Paid Make.com plan recommended for webhooks, routers, and error handlers.
• A Google Workspace account with access to the calendar you want to verify events on.
• ClickUp workspace and API token or Make connection with a Space, Folder, and List where tasks will be created. Ensure user has permission to create tasks and add attachments.
• Slack workspace with a channel for notifications and a bot user connected to Make.com.

Prerequisites and permissions: Make sure Make.com has OAuth or API access for each app, and that ClickUp workspace webhooks or API rate limits are acceptable for your volume.

How It Works (The Logic)

Trigger: Calendly sends invitee.created, invitee.canceled, or invitee.rescheduled to a Make.com webhook.

Flow overview in plain English:

1. Receive webhook and normalise payload, extract event_uuid and invitee_uuid.
2. Fetch full invitee details via Calendly RESTs if needed.
3. Verify the corresponding Google Calendar event exists and matches the booking (prevents ghost bookings).
4. Idempotency check: search ClickUp for a task with Calendly invitee_uuid or event_uuid to avoid duplicates.
5. Create or update a ClickUp task with mapped fields, add checklist items (pre-call actions), set due date/time and assignee, attach any files or pre-call form responses.
6. Post a Slack message and start a thread linking to the ClickUp task and Google Calendar event.
7. For cancel/reschedule events, update the ClickUp task status and edit the Slack thread with the new state.

In short: Calendly webhook → validate Google Calendar event → ClickUp upsert → Slack thread update.

Step-by-Step Setup

1. Create the Calendly webhook listener in Make.com

• Module: Webhooks > Custom webhook. Name it "Webhook: Calendly invitee events".
• Copy the webhook URL and register it in Calendly's webhook subscriptions for events: invitee.created, invitee.canceled, invitee.rescheduled.

Gotcha: Calendly can send multiple events for a reschedule (canceled + created). Design your receiver for idempotence and to handle sequences.

2. Normalise the incoming payload and fetch full invitee details

• First Make module after the webhook: Tools > JSON Parse or Set Variables to extract event, event_type, event_uri, payload.scheduling.url, event_uuid, and invitee_uuid.
• If the webhook payload is minimal, call Calendly API: GET /scheduled_events/{event_uuid}/invitees/{invitee_uuid} to retrieve invitee answers, name, email, and invitee answers. Use your Calendly API token in the HTTP module.

Field mapping you'll need downstream:

• booking_id = invitee_uuid
• event_id = event_uuid
• start_time (ISO UTC)
• end_time (ISO UTC)
• invitee_name, invitee_email
• booking_questions (array of question/answer pairs)

3. Verify Google Calendar event exists and get the calendar_event_id

• Module: Google Calendar > Search Events (use the calendar you authorise). Query by time window around start_time and by event summary or the Calendly scheduling URL if Calendly included a meeting link.
• If an event is found, capture its event ID and location/conference link.
• If not found, branch to an error-handling route where you either retry (short backoff) or create a placeholder ClickUp task flagged "calendar missing" and notify ops.

Why: Calendly callbacks can arrive before the calendar update is reflected in the calendar provider. Confirming the event reduces false positives.

4. Idempotency check in ClickUp

• Module: ClickUp > Search Tasks in List. Use a custom field or task name convention that includes booking_id or event_id. For example task name: "Booking: {{invitee_name}} — {{booking_id}}".
• If a task exists, route to the update path. If not, continue to create.

Practitioner tip: create a dedicated ClickUp custom field named Calendly ID and search by that field. This is more robust than string-matching names.

5. Build the ClickUp task payload and create or update the task

Create path (ClickUp > Create Task):

• Name: Booking: {{invitee_name}} — {{booking_id}}
• Description: include a compact block with: booking time (localised), invitee email, Calendly event link, pre-call answers (map question -> answer), and a direct Google Calendar event link. Example:
  • "Start: 2026-07-30T10:00 Europe/London (local)",
  • "Meeting link: {{conference_url}}",
  • "Answers: Q1: ..."
• Due date / start date: map to booking start_time (ClickUp supports start_date/due_date). Convert to the workspace time zone if required.
• Custom fields: set Calendly ID, Event ID, and Booking Source = Calendly.
• Assignee: map using logic from booking_questions (for example, if the form asked "Preferred owner" map to ClickUp user) or set a default owner from a lookup table in Make using the booking data.
• Add a prebuilt checklist (subtasks or checklist) using ClickUp's checklist API or by creating subtasks:
  • Checklist items: "Review pre-call answers", "Prepare demo environment", "Attach pre-call brief".
• Attachments: if invitee submitted files via Calendly or you have pre-call attachments in Drive, fetch and attach them using ClickUp > Upload Attachment.

Update path (ClickUp > Update Task):

• If the event was rescheduled, update start_date and description with the new time and change status to "Rescheduled" or add a comment noting the change.
• If the event was canceled, set status to "Canceled" and add a comment with who canceled and the cancel reason if provided.

Common gotcha: ClickUp API rate limits; batch checklist creation into one request where possible, and avoid creating many small API calls inside loops without sleeps for high volume.

6. Post the Slack message and start or update a thread

• Module: Slack > Post Message to Channel. Post a single top-level message for the booking in the team channel. Content example:
  • "New booking: {{invitee_name}} for {{service}} on {{start_local}}. ClickUp task: <{{clickup_task_url}}|Open task>. Calendar: <{{calendar_event_url}}|Open event>."
• Capture the ts (timestamp) of the Slack message.
• For subsequent updates (reschedule or cancel), use Slack > Post Message in thread by providing the thread_ts to append updates rather than posting new top-level messages.

Why thread updates: keeps conversation together and prevents channel noise.

7. Observability and logging

• Append a row to a Google Sheet or a ClickUp log list with: booking_id, event_id, start_time, clickup_task_id, slack_ts, calendar_event_id, inbound_payload_raw, outcome (created/updated/canceled), timestamp.
• This log is critical for replaying flows and diagnosing duplicates or missed calendar events.

8. Error handling and retries

• Configure Make.com scenario error handlers for API calls. For transient errors (5xx, 429), retry with exponential backoff. For permanent errors (4xx bad request), route to a human ops path and set the ClickUp task to status "Manual Review".
• For missing calendar events, implement a short retry loop (for example check again after 15s and 60s) before creating a flagged task.

Real-World Business Scenario

A product consultancy used this exact pattern for client discovery calls. Calendly invitees often included a project brief and a preference for the account owner. After implementing the automation, every booking produced a ClickUp task with the client brief attached, a pre-call checklist, and a Slack thread where the account owner and PM coordinated. When a client rescheduled, the ClickUp task moved dates automatically and the Slack thread updated rather than creating noise in the channel. The team reduced meeting prep time by 70 percent and never missed a required pre-call action.

Common Variations

• Start from Google Calendar RSVPs rather than Calendly: use Google Calendar push notifications as the primary trigger if bookings sometimes appear from other schedulers.
• Add enrichment: call Clearbit or HubSpot in Make to add company data to the ClickUp task before assigning an owner.
• Use ClickUp subtasks for multi-role handoffs: automatically create separate subtasks for Sales, Engineering, and Ops with different checklists.

What you built and next steps

You built a robust scheduling automation that receives Calendly webhooks, verifies the calendar event in Google Calendar, creates or updates a ClickUp task with detailed booking data and checklists, and posts a Slack message with threaded updates for reschedules and cancellations. The scenario includes idempotency checks, retry logic, and observability for troubleshooting.

If you want this implemented for your exact ClickUp lists, Slack channels, and booking form fields, Olmec Dynamics builds and operates these kinds of automations for businesses. Learn more about how we deliver scheduling and handoff automations at https://olmecdynamics.com.