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

Introduction

If you run scheduling through Calendly, the manual pain usually shows up in ClickUp and Slack. Someone gets a booking, then an operator copies invitee details, creates a task, pastes the meeting link, and posts the notification. It is slow, inconsistent, and it breaks when bookings happen close together.

With this Cross-Platform Automation (XPA), you will wire Calendly to Make.com so every new booking becomes a ClickUp task automatically, then sends a Slack alert. By the end, you will know the exact setup steps, the field mappings that matter, and how to prevent duplicate ClickUp tasks when webhooks replay.

What You'll Need

• Make.com scenario access (paid plan may be required depending on how you use webhooks and scenario runs).
• Calendly access to configure webhooks and receive event.created events.
• ClickUp access to create tasks in the target space/folder/list.
• Slack app connection with permission to post messages (chat:write) to the channel you choose.
• A unique ClickUp search key you can reliably match. Recommended approach: a ClickUp custom field to store Calendly event_id.

If you want the broader XPA context, you can read our Cross-Platform Automation (XPA) guide.

How It Works (The Logic)

The automation logic is: Calendly webhook event.created triggers a Make.com scenario. Make.com parses the payload, extracts key fields including Calendly event_id, then searches ClickUp for an existing task with that same event_id. If found, it can update or skip, and if not found it creates the task. Finally, Make.com posts a concise Slack message that includes the ClickUp task link.

Idempotency is the whole trick: you treat event_id as the canonical key so duplicates from webhook retries do not create duplicate tasks.

Step-by-Step Setup

1) Create a ClickUp custom field for the dedupe key

In ClickUp, add a custom field to your target list:

• Field name: Calendly Event ID
• Type: text

You will store Calendly event_id here for every created task.

2) Connect your apps in Make.com

In Make.com, create/verify connections for:

• Calendly
• ClickUp
• Slack

Use the same workspace credentials you want tasks to be created under.

3) Create the Make.com scenario using a Custom Webhook trigger

In Make.com:

1. Build a new scenario
2. Add a trigger: Webhooks → Custom webhook
3. Copy the webhook URL
4. Turn on scenario and keep it in test mode

Gotcha: keep this scenario running while you test the webhook subscription in Calendly.

4) Subscribe Calendly to your Make.com webhook

In Calendly:

1. Go to Webhooks
2. Add a webhook subscription
3. Point it to your Make.com Custom Webhook URL
4. Select event.created (and add other event types only if you need updates/cancellations)

Trigger a test booking from Calendly so you have a real payload to map.

5) Map and normalize the payload fields you need

In the Make.com scenario after the webhook trigger, create mapping steps so you can consistently reference values. Map at minimum:

• event_id (your dedupe key)
• invitee name
• invitee email
• event type (Calendly meeting type)
• start time
• meeting link (or location URL)

Production tip: keep timestamps in a consistent timezone format in Make.com for display, then convert only where needed.

6) Search ClickUp for an existing task using Calendly Event ID

Add a ClickUp step to find or list tasks in the correct list.

• Your filter condition should match ClickUp custom field Calendly Event ID equals the payload event_id.

If Make.com’s ClickUp module in your setup does not filter by custom field inside the search module, do it in two phases:

1. List tasks in the target list
2. Filter using a Make.com filter condition on the custom field value

7) Branch: create only if no task exists

Use a router or an “if” condition based on whether the search returned a task.

• If none found → create task
• If found → update task or skip (for a simple run, skip is fine)

Task creation fields to set:

• Name: Calendly: {Invitee Name} - {Event Type}
• Description: include start time, meeting link, invitee email
• Custom field: set Calendly Event ID to payload event_id

Gotcha: do not rely only on task title for dedupe. Titles can change, and the same attendee may book twice.

8) Post the Slack notification with the ClickUp task link

Add a Slack step to send a channel message.

• Channel: your routing channel, for example #booking-alerts

Message template that works in practice:

• New Calendly booking: {Invitee Name} ({Event Type})
• Start: {Start Time}
• Task: {ClickUp task URL}

Make sure you pull the ClickUp task URL (or build it from task id) from the create step output.

9) Add a failure path for missed payloads

In Make.com, set error handling so you can recover quickly:

• In the simplest setup, send an error Slack message to #ops-alerts
• For slightly more structure, insert the raw payload fields into a Google Sheet for manual review

The goal is fast visibility when ClickUp is down, Slack rate limits hit, or the Calendly payload changes.

10) Test with two bookings and validate dedupe

Run two test bookings in quick succession.

• Confirm one ClickUp task per unique event_id
• Confirm one Slack message per created task

If you see duplicates, the issue is almost always one of these:

• event_id mapping is wrong or blank
• ClickUp search is not actually matching the custom field value

If you want a reference layout for the same integration pattern, see Calendly → ClickUp: Make.com Create Task + Slack Notify.

Real-World Business Scenario

An appointment-heavy service firm runs discovery calls through Calendly and tracks delivery readiness in ClickUp. Before automation, the intake coordinator spent 30 to 60 minutes per day copying booking details into ClickUp and then posting status updates in Slack.

With this Make.com XPA, each booking creates a standardized ClickUp task immediately, with the meeting link and invitee email in the description. Slack gets a short alert with the ClickUp task URL so the team can take action without searching. The firm also stopped duplicate tasks from webhook retries by deduping on Calendly event_id.

Common Variations

1. Route by event type to different ClickUp lists Add a router right after mapping event_type, then create tasks in the correct list.

2. Update the task on webhook replays Instead of skipping when a task exists, run a ClickUp update task step to refresh description and start time.

3. Only notify Slack for specific event types or schedules Add a Make.com filter before the Slack step, for example notify only for “Pricing call” or only during business hours.

4. Log each processed booking in a Google Sheet Store event_id, ClickUp task id, and Slack message timestamp for easy audit and support.

The workflow you now have in place

You built an XPA that listens for Calendly bookings, creates or skips ClickUp tasks idempotently using Calendly event_id, and posts a Slack notification with an actionable link. That is the exact pattern we reuse across many operations teams because it keeps scheduling, delivery intake, and communications aligned.

If you want Olmec Dynamics to tailor the field mappings to your ClickUp structure, build the dedupe safely for your payload, or add the right error handling for your volume, you can see what we do at Olmec Dynamics.