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

Introduction

A common operational gap is that booked meetings live in Calendly while work lives in ClickUp. Manually copying booking details into tasks wastes time and causes missed pre-meeting prep. You want bookings to appear in ClickUp as properly named, scheduled tasks with the right assignee, attachments, and a Slack heads-up so the team can act.

This guide builds a production-grade, idempotent Calendly → Make.com → ClickUp workflow that also posts an interactive summary to Slack. It handles new bookings, reschedules, and cancellations, normalises time zones, and keeps a mapping so you update the same ClickUp task instead of creating duplicates.

What you will know by the end: the exact Make.com modules to use, the field mappings for ClickUp task creation, how to deduplicate and update on reschedules, and how to post Slack messages with action buttons.

What You'll Need

• Calendly account with webhook access for your event types (webhooks are available on most paid plans; polling is an alternative but less desirable)
• Make.com account with active connections for Calendly (or HTTP webhook), ClickUp, and Slack (paid Make.com plan recommended for advanced scenarios and retries)
• ClickUp workspace access and API token (ability to create tasks and write to custom fields)
• Slack workspace and a bot token with permission to post messages and use interactive components
• A small datastore: Google Sheets or Make.com Data Store to map Calendly event invitee IDs to ClickUp task IDs (used for idempotency and reschedule/cancel updates)

Permissions note: ClickUp custom fields use numeric IDs; create any required custom fields first and capture their IDs for mapping.

How It Works (The Logic)

Trigger: Calendly webhook for booking created, rescheduled, or cancelled. Make.com receives the webhook, normalises the payload (time zone, invitee list, event type), then checks your mapping store for an existing ClickUp task. If none exists on a created booking, Make creates a ClickUp task and saves the mapping (Calendly_event_uri or invitee_id ↔ ClickUp_task_id). For reschedules, Make updates the existing task's due date and posts an update in Slack. For cancellations, Make marks the task cancelled or moves it to a ClickUp list for cancelled meetings.

In plain flow terms: Calendly webhook → Normalise payload → Dedupe check (mapping store) → Create or Update ClickUp task → Post interactive Slack message → Persist mapping and audit log.

Step-by-Step Setup

1. Create Calendly webhooks

• In Calendly, register webhooks for the event scopes you need: invitee.created, invitee.canceled, invitee.rescheduled. Point the webhook to a Make.com HTTP webhook URL (create this in Make first).
• Test with Calendly’s webhook test tool and ensure Make receives the sample payload.

Gotcha: Calendly timestamps are ISO + timezone. Always send the received timezone through your normalisation step rather than assuming UTC.

2. Build the canonical payload in Make.com

Modules:

• HTTP > Webhook (Custom webhook) — receives the Calendly payload
• Tools > JSON → Parse the webhook body if necessary

What to extract and normalise before branching:

• calendly_event_uri (unique event id) or invitee.uuid
• event_type name
• invitee name and email
• start_time and end_time (convert to the workspace timezone using Make’s date functions)
• location and any answers to invitee questions

Create a single mapped object in Make called booking: {id, event_type, start, end, invitee_name, invitee_email, timezone, answers}

3. Add an idempotency check (mapping store)

Options for store:

• Make.com Data Store (recommended for stability) or Google Sheets table

Flow:

• Search store for booking.id (Calendly event or invitee id)
• If found: fetch the stored clickup_task_id and route to the Update branch
• If not found: route to the Create branch

Why it matters: retries and webhook duplicates happen. Deduplicate on Calendly's unique event identifier.

4. Create ClickUp task (Create branch)

Module: ClickUp > Create Task

Field mappings (example):

• Task name: "Meeting: {{event_type}} — {{invitee_name}}"
• Description: include Calendly link, invitee answers, and an auto-generated pre-meeting checklist (use markdown)
• Due date: map to start_time (or set a separate due_date custom field)
• Assignee: map by email to ClickUp user or leave unassigned and add a "needs assignment" tag
• Custom fields: map event type, invitee_email, timezone, and a calendly_event_id field (use the numeric custom field key)
• List/Folder: choose the ClickUp List where scheduled meetings belong

Post-create actions:

• Save clickup_task_id into your mapping store alongside calendly_event_id
• Add an audit row to Google Sheets (optional) with payload and task ID for troubleshooting

Gotcha: ClickUp rate limits and required numeric IDs for custom fields. Keep the ClickUp field mapping table in Make to avoid hardcoding numeric values scattered in modules.

5. Handle reschedules and cancellations (Update branch)

If the mapping store returns an existing clickup_task_id:

• Module: ClickUp > Update Task
• Update fields: due date/time, description with new time, add a comment noting the reschedule or cancellation
• For cancellations: set a custom status like "Cancelled" or move the task to a dedicated list for cancelled meetings

Also post a follow-up message into Slack summarising the change.

Gotcha: Calendly reschedule may create a new invitee.created event depending on settings. Always dedupe by Calendly’s event id or invitee.uuid and validate the event relationship before acting.

6. Post an interactive Slack message

Module: Slack > Post message (use blocks)

Message content for new bookings:

• Header: "New booking: {{event_type}} — {{invitee_name}}"
• Body: time (workspace local), invitee email, event link, short invitee answers
• Actions block: buttons such as "Open in ClickUp" (link to task), "Assign" (deep link to a ClickUp assignment form or trigger a secondary Make flow), "Create Pre-Call Note" (calls a Make webhook to attach a templated note)

For reschedules/cancellations, post an update message and optionally thread it under the original booking message.

Gotcha: Slack interactive components require a request URL for actions. If you need post-click processing, create a small Make webhook endpoint to receive the action payload and continue the flow.

7. Error handling and dead-letter queue

• If ClickUp creation or update fails, add the webhook payload and error details to a dead-letter Google Sheet or Data Store row and post a short alert to a private Slack channel for ops.
• Implement retries in Make.com with exponential backoff for transient HTTP errors.

8. Testing checklist

• Simulate a booking: verify ClickUp task created with correct name, due date, and custom fields
• Simulate a reschedule: confirm task due date updates and Slack message posts
• Simulate a cancellation: confirm task status moves to Cancelled and mapping persists
• Test webhook duplicate delivery: ensure no duplicate tasks are created
• Test timezone edge cases: invitee in different timezone and your workspace timezone mapping

Real-World Business Scenario

A recruitment agency we worked with used this exact pattern. Every candidate interview booked via Calendly spawned a ClickUp task assigned to the interview coordinator with the candidate details and a pre-interview checklist. Reschedules updated the same ClickUp task and sent an automated Slack update to the panel. The agency removed manual task creation from the coordinator’s workflow and cut interview scheduling admin by two hours per week.

Common Variations

• Create pre-call resources: add a step that generates a one-page brief in Google Docs or a PDF using the candidate answers, attach it to the ClickUp task, and surface a link in Slack. See our guide on PDF generation for implementation details in Make.com How to Generate a PDF from a Google Docs Template Using Make.com and Gmail.
• Multi-event workflows: if an event type spawns multiple internal tasks (prep, follow-up, billing), use Make routers to create a task group in ClickUp and link them via dependencies.
• AI-assisted notes: for longer meetings, call an LLM to generate a short meeting agenda from invitee answers and add it to the ClickUp description, inspired by our work with OpenAI classification for inbound messages How to Automatically Classify Support Emails Using Gmail, OpenAI, and Zendesk in Make.com.

Next steps and how we help

You now have an advanced blueprint for transforming Calendly bookings into reliable ClickUp tasks and Slack notifications using Make.com, including idempotency, reschedule handling, and interactive Slack actions. If you want this implemented, tuned for your ClickUp custom fields, or extended with document generation or AI summarisation, Olmec Dynamics builds and operates these integrations for teams. See what we do at https://olmecdynamics.com.