How to Create ClickUp Tasks from Calendly Bookings Using Make.com and Post Slack Alerts

Introduction

If your team still copies meeting details from Calendly into ClickUp and then types a Slack message, you are adding minutes per booking and missing a consistent handoff. Manual steps lead to missing context, wrong assignees, and slower meeting prep.

This guide shows a pragmatic Make.com build that listens for Calendly invitee events, creates a ClickUp task with mapped fields and custom field values, and posts a Block Kit Slack message with a direct link to the new task. What you will know by the end: the modules to use, exact field mappings, idempotency checks, and cancellation handling.

What You'll Need

• Calendly account with webhook access and permissions to create event subscriptions (public webhook endpoint required). Paid Calendly plans may be needed for advanced webhook features.
• ClickUp workspace with a target List (or Space and Folder) and the custom field IDs you will populate. API token with write scope.
• Slack workspace and a bot token able to post messages into the target channel.
• Make.com account with connections for Calendly, ClickUp, and Slack. A paid plan is recommended for production reliability and execution quotas.
• Basic JSON parser familiarity and a place to store mapping config (Make.com variables or a small config sheet).

How It Works (The Logic)

Trigger: Calendly sends an invitee.created webhook when someone books, invitee.canceled when they cancel, and invitee.rescheduled for changes. Make.com receives the webhook, normalises the payload, checks for duplicate processing, creates a ClickUp task, sets custom fields using ClickUp's Set Custom Field Value calls, and then posts a Slack Block Kit message linking to the ClickUp task. For cancellations, the scenario updates the ClickUp task status or adds a cancellation comment.

In short: Calendly webhook → Make.com parse + dedupe → ClickUp create task → ClickUp set custom fields → Slack post notification (or ClickUp update on cancel).

Step-by-Step Setup

1. Subscribe to Calendly webhooks and test deliveries

• In Calendly create a webhook subscription for the events you need, at minimum invitee.created and invitee.canceled.
• Point the webhook at a Make.com custom webhook (Module: Webhooks > Custom webhook), and enable payload signature verification if you want to validate X-CALENDLY-SIGNATURE.
• Test by booking a real test slot so you can inspect the live payload in Make. Log the raw payload for mapping.

Gotcha: Calendly can retry deliveries. Use the invitee URI or event.uri and invitee.uri as idempotency keys to avoid double processing.

2. Create the Make.com scenario and add the Calendly webhook

• Module 1: Webhooks > Custom webhook, create and paste the URL into Calendly.
• Fetch a sample payload inside Make.com. Extract these fields for mapping: invitee name, invitee email, event type name, start_time (ISO 8601), end_time, location, and the event.uri or invitee.uri id.

3. Idempotency check (prevent duplicates)

• Module 2: Data Store or Google Sheets lookup. Use invitee.uri as the unique key. If the key exists and status is processed, stop the run.
• If not present, write a provisional row/item with status processing and continue.

Why: Calendly retries and accidental replays can otherwise create duplicate ClickUp tasks.

4. Create the ClickUp task

• Module 3: ClickUp > Create a Task. Map basic fields:
  • list_id: your destination List ID
  • name: Calendly: {{invitee_name}} — {{event_type}}
  • description: include booking details: start, end, timezone, notes, Calendly booking URL, and the invitee email
  • assignees: optional, map to the workspace user ID if you have deterministic assignment rules
  • due_date: use the meeting start time or leave blank depending on your workflow

Example description template:

Booking URL: {{event.uri}}
Invitee: {{invitee_name}} <{{invitee_email}}>
Starts: {{start_time}}
Ends: {{end_time}}
Notes: {{invitee_questions}}

Gotcha: ClickUp list_id is required. Confirm the target List before running the scenario.

5. Populate ClickUp custom fields

• ClickUp custom fields require Set Custom Field Value calls after the task is created. Use the returned task_id from the create step.
• For each custom field you want to set, add Module 4+: ClickUp > Set Custom Field Value (or the HTTP call if you need a field type not covered by the connector).

Typical custom fields to set:

• Event Type (dropdown) → use the exact dropdown option id or value used in ClickUp
• Booking Time (date/time) → convert ISO to epoch ms if required
• Invitee Email (text)
• Meeting Link (url)
• Internal Client ID (text or relation)

Mapping tip: store your ClickUp custom field IDs in scenario variables or a small lookup table so you can reuse the scenario across environments.

6. Post an actionable Slack message

• Module final: Slack > Post message (use Blocks). Build a compact Block Kit payload with:
  • Header: New Calendly booking and event type
  • Sections: Invitee name and email, start time localised, short notes
  • Actions: Button linking to the ClickUp task URL (https://app.clickup.com/t/{{task_id}})

Example Slack text: "New booking: Jane Doe • 30-min intro • Starts 2026-05-05 09:00 local — <Open in ClickUp|{{clickup_task_url}}>".

Gotcha: Slack rate limits exist. If you expect many bookings, consider batching or conditional messages for only important event types.

7. Handle cancellations and reschedules

• Add a router at the start splitting by Calendly event type. For invitee.canceled run the cancellation path:
  • Search ClickUp for the task created for the original invitee or use a stored task_id from your Data Store.
  • Update the task status to Cancelled or add a comment like "Booking cancelled by invitee". Optionally post a Slack update to the original channel.
• For invitee.rescheduled, update the task due_date and add a comment noting the new time.

Testing tip: simulate a cancellation in Calendly and verify the ClickUp task status changes and Slack receives the cancellation note.

8. Finalise and monitor

• Turn the scenario on and monitor the first 48 hours of runs. Check your Data Store audit rows, ClickUp tasks, and Slack messages for correct mappings.
• Add an error branch to notify an ops channel if ClickUp API returns 4xx or 5xx errors, and mark the Data Store row as error so you can retry manually.

Real-World Business Scenario

A product consultancy used this setup to automate client meeting handoffs. Each new discovery call created a ClickUp task prefilled with client name, calendar link, and pre-call notes. The delivery Slack channel got a single tidy alert with the ClickUp link. The delivery lead removed manual copying and reduced meeting prep time by 10 minutes per booking, keeping the team ready before each call.

Common Variations

• Create a pre-call checklist in ClickUp: add a template checklist when creating the task so consultants have a ready agenda.
• Add owner routing: use event type or invitee email domain to pick assignees dynamically, then map the chosen user ID into the ClickUp create call.
• Generate calendar invites into a shared calendar: after task creation add a Google Calendar event for internal participants to ensure visibility.

Where this fits in your automation stack

You have now a practical Make.com pattern to turn Calendly bookings into ClickUp tasks and Slack notifications with idempotency, custom field handling, and cancellation support. For a worked example of a similar flow see our existing guide on creating ClickUp tasks from Calendly bookings, and for related ClickUp → Slack routing patterns see our post on ClickUp task notifications. If you want this built and hardened for your workspace, Olmec Dynamics implements and operates these automations for teams. Learn more about our work at Olmec Dynamics.