How to Create ClickUp Tasks with Templated Checklists and Zoom Links from Calendly Using Make.com

Introduction

When a Calendly booking arrives someone usually has to create the ClickUp task, add the meeting prep checklist, paste the Zoom link, and tell the team in Slack. That manual chain introduces typos, missed prep, and no single audit trail for who did what.

In this advanced guide you will build a Make.com scenario that handles the whole flow end-to-end. When Calendly fires an event.created webhook, Make.com will: create or find a ClickUp task, add a templated checklist via the ClickUp checklist API, attach the Zoom cloud recording or meeting link to the task, post a concise Slack alert, and append a row to Google Sheets for auditing and idempotency. By the end you will have a production-ready pattern with idempotency, retry handling, and error routing.

What you will know by the end: exact Make.com modules to use, how to parse Calendly payloads safely, the ClickUp checklist API call to use, how to locate Zoom links, the field mappings, and common gotchas to watch for.

What You'll Need

• Calendly account with webhook access (Calendly webhooks require a paid plan for webhooks), and the ability to subscribe to invitee.created or event.created.
• A ClickUp workspace with API access and permission to create tasks and checklists in the target List. You need a ClickUp API token.
• Zoom account with cloud recording enabled and API access (paid Zoom plan required for cloud recordings). API key/secret or JWT/OAuth depending on your Zoom setup.
• Slack workspace with a channel for notifications and an app token authorised by your workspace.
• Google Sheets file for the audit log and idempotency store. Share it with the Make.com connection account.
• A Make.com account to orchestrate the scenario. Paid tier recommended for webhook reliability and retries.

Notes: Calendly payload formats changed in recent API versions. Treat the webhook payload as authoritative for the event id, invitee id, start/end time and timezone. Always test with representative payloads.

How It Works (The Logic)

Trigger (Calendly event.created) → Validate and dedupe using Google Sheets → Parse invitee and event fields → Create or find ClickUp task (search by Calendly event ID stored in a custom field) → Add a templated checklist via ClickUp POST /task/{task_id}/checklist → Fetch Zoom meeting info (meeting link or cloud recording) and attach link to task description or custom field → Post Slack message for the team → Append audit row to Google Sheets.

In plain terms: Calendly webhook → Make.com orchestration → ClickUp task + checklist + Zoom link → Slack alert → audit log.

Step-by-Step Setup

1. Design the ClickUp task and checklist template approach

• Decide the ClickUp List where tasks should be created and create a custom text field named calendly_event_id or similar to store the Calendly event ID. This is your dedupe key.
• Prepare a checklist template concept: a named checklist with 4–8 items (for example: "Review client brief", "Prepare slide deck", "Send pre-meeting materials", "Confirm access"). You will create checklist items via API when the task exists.

Why store the Calendly event id in ClickUp: it prevents duplicates when the webhook retries or Calendly issues reschedules.

2. Create the Calendly webhook in Calendly

• Create a webhook subscription for the event.created or invitee.created event pointing at the Make.com custom webhook URL. In Calendly choose the exact event type you use for booking creation.
• In Make.com create a Custom webhook module and copy the generated URL into Calendly.

Gotcha: reschedules and cancellations send different event types. Handling reschedules requires extra logic (see Common Variations). Start with event.created for new bookings.

3. Build the Make.com scenario, module-by-module

• Module A: Webhooks — Custom webhook (trigger). Accept POST from Calendly. Name it TRIGGER: Calendly event.created.
• Module B: Tools — JSON parse (optional). Immediately parse the payload and extract: event.uri or event.id, invitee.uuid or invitee.id, invitee.name, invitee.email, event.start_time, event.end_time, event.location (conference link), event.metadata (hidden fields), and event.answers if you use Calendly questions.

4. Idempotency check using Google Sheets

• Module C: Google Sheets — Search rows. Look for a row where calendly_event_id equals the incoming event.id. If a row exists stop the flow; the event was already processed.
• If not found continue. This protects against duplicate webhook deliveries and makes retries safe.

Implementation detail: use a lightweight sheet with columns: calendly_event_id, clickup_task_id, invitee_email, run_id, created_at, status.

5. Find or create the ClickUp task

• Module D1: ClickUp — Search tasks in the List by the calendly_event_id custom field if your connector supports it. If your ClickUp connector does not search by custom field, keep a mapping in Google Sheets and use that instead.
• Module D2: Router branch A (found): take the returned task id and continue to checklist step.
• Module D3: Router branch B (not found): ClickUp — Create a Task. Map fields:
  • Name: "Meeting: {{event_name}} — {{invitee_name}}"
  • Description: include invitee email, Calendly link, answers to pre-meeting questions, and ISO start time.
  • Custom field calendly_event_id: set to event.id
  • Due date or start date: set to event.start_time converted to ClickUp format

Common gotcha: ClickUp connectors sometimes want timestamps in epoch milliseconds. Use Make.com date functions to convert ISO to epoch when needed.

6. Add a templated checklist to the ClickUp task

• Module E: HTTP — Make a request to ClickUp's API to create a checklist. Use the ClickUp endpoint POST /task/{task_id}/checklist and supply a body with the checklist name and items. Example body: { "name": "Pre-meeting checklist", "items": [ {"name":"Review brief"}, {"name":"Upload slides"}, {"name":"Book demo environment"} ] }

• Use Make.com HTTP module for this call, passing the ClickUp API token in the Authorization header.

Gotcha: ClickUp checklist creation is a separate endpoint from task creation. Creating the task then adding the checklist in a subsequent HTTP call is the reliable pattern.

7. Fetch Zoom meeting info and attach link

Two patterns depending on how the meeting was scheduled:

• If Calendly created the Zoom meeting and included the conference join_url in the payload, map that into the ClickUp task description immediately.
• If the Zoom meeting must be found after-the-fact (for example, to attach the cloud recording after the meeting ends), store the ClickUp task id and Calendly event id, then run a follow-up scenario that triggers when the meeting ends or on a scheduled poll.

For attaching the immediate join link:

• Use the location or event.conference data from Calendly. Update the ClickUp task description via ClickUp Update Task module or HTTP patch to append a line: "Zoom link: {{join_url}}".

For attaching post-meeting cloud recordings:

• Use a separate scenario that triggers on meeting end or a Zoom webhook, searches recordings by meeting UUID or host email within the event time window, and then updates the ClickUp task to add "Recording: {{play_url}}". Zoom meeting UUIDs may require URL encoding; test the endpoint with your environment first.

8. Post a concise Slack alert

• Module F: Slack — Post message. Post into your team channel with a short payload:
  • "New booking for {{invitee_name}} — {{event_start_local}} • <{{clickup_task_url}}|Open task> • Zoom: {{join_url || 'TBD'}}"

Filter alerts so you do not flood Slack. For example only notify for external bookings or for event types that require preparation.

9. Append an audit row in Google Sheets

• Module G: Google Sheets — Add a row. Write calendly_event_id, clickup_task_id, invitee_email, created_at, checklist_created = true, slack_notified = true, run_id.

This row is your single source of truth for idempotency and helps troubleshooting if something needs a manual rerun.

10. Error handling and retries

• Use Make.com error handlers. On HTTP 429 or other transient ClickUp/Zoom errors implement exponential backoff and retry.
• For permanent failures, update the Google Sheets row with status = error and post a detailed message into a private ops Slack channel including the run_id, payload snapshot link, and error details.

Real-World Business Scenario

A digital agency used this pattern for client onboarding calls. Every Calendly booking created a ClickUp task with a 6-item onboarding checklist and automatically included the Zoom join link. The PM channel in Slack received a single clear alert with the task link. The audit sheet let operations reconcile missed checklists and replay failed runs. The agency cut manual task creation time and improved readiness for calls so that each meeting started with the same prep done.

Common Variations

• Post-meeting recording attach: run a secondary scenario that consumes Zoom webhooks or polls Zoom for cloud recordings and appends recording links to the ClickUp task once available.
• Dynamic assignee routing: use a Google Sheets lookup table keyed by event type to map bookings to specific ClickUp assignees or teams.
• Reschedule handling: listen to Calendly's reschedule events, look up the stored calendly_event_id, update the existing task dates, and add a checklist item "Confirm time change with client." That avoids creating duplicate tasks on reschedule.

Where this fits and related reading

This pattern extends the simpler Calendly to ClickUp flow. For a compact reference on creating ClickUp tasks from bookings see our guide on creating tasks from Calendly bookings How to Create ClickUp Tasks from Calendly Bookings Using Make.com and Slack. For Slack routing and status alert ideas review How to Automatically Notify Slack When a ClickUp Task Changes Status Using Make.com.

Putting it into practice

You now have a production-ready architecture to convert Calendly bookings into ClickUp tasks with templated checklists, Zoom join or recording links, Slack alerts, and a replayable Google Sheets audit. If you want this built and tuned across Calendly, ClickUp, Zoom, Slack, and Google Sheets, Olmec Dynamics implements these automations for real businesses. See what we do at https://olmecdynamics.com.