How to Create ClickUp Tasks from Microsoft Teams Messages Using Make.com

Introduction

You get an actionable message in Microsoft Teams and someone needs to turn it into work. The manual loop is copying the message into ClickUp, pasting attachments, and then posting the task link back into the thread. That loses context and causes delays.

This guide shows a reliable Make.com pattern that turns a Teams message into a ClickUp task, preserves the message text and attachments, prevents duplicates, and replies in-thread with the new task link. By the end you will have a maintainable micro-automation you can roll out to your team.

What you will know by the end: the exact Teams trigger to use, how to map message fields into ClickUp, how to avoid duplicate tasks, and the minimal error handling you should include.

What You'll Need

• A Microsoft Teams workspace where you can add the Make.com app or use an incoming message/shortcut trigger
• ClickUp account with permission to create tasks in the target List, and knowledge of any custom field IDs you will set
• Make.com account with connected Teams and ClickUp apps, and access to create scenarios
• (Optional) A small Google Sheet or Make.com Data Store to record processed message IDs for idempotency

Notes: If you plan to attach files to the ClickUp task you will need the Make.com Teams connector to be authorised to fetch file content, or include file links in the task description instead.

How It Works (The Logic)

Trigger (Teams message action or reaction) → extract message text, author, timestamp, thread and file links → idempotency check (has this message already been turned into a task?) → create ClickUp task with name, description and optional custom fields → store mapping (Teams message id → ClickUp task id) → post task link back into the original Teams thread.

Triggering from a user action keeps the flow user-driven and avoids creating tasks from noise.

Step-by-Step Setup

1. Choose the trigger pattern in Teams

You have two reliable options:

• Message action (recommended): add a Teams message action/shortcut so anyone can select a message and run the automation on demand.
• Reaction trigger: use a specific reaction (for example :task:) to mark a message for conversion.

Message action is the best user experience for deliberate task creation. Reaction-based workflows are fine when you want a very quick lightweight pattern.

2. Create a new scenario in Make.com and add the Teams trigger

• Add the Microsoft Teams trigger that captures either the message action payload or reactions depending on your choice. Make sure the trigger returns the message id (messageId or activityId), channel id, conversation id, message text, message timestamp, and any file references.
• Run a manual test by performing the action in Teams so Make.com captures a sample payload.

3. Extract and normalise the message fields

Map these values into scenario variables you'll use later:

• teams_message_id: unique id for the message (use as the dedupe key)
• teams_channel_id and conversation_id: to reply in-thread
• message_text: full message body, optionally trimmed to a sensible length for the task name
• message_author: display name and user id
• message_ts: timestamp for context
• attachments or file links: collect URLs if present (note Teams file links may require special permissions to fetch)

Sanitise text: trim whitespace, remove excessive markup, and shorten the first line for the task title.

4. Idempotency: prevent duplicate tasks

Before creating a task, check whether you already processed this message. Two practical options:

• Google Sheets lookup: keep a simple ledger with columns message_id, clickup_task_id, processed_at
• Make.com Data Store: store a key entry keyed by teams_message_id

If an entry exists, stop the run and optionally post a reply stating the task already exists. If not, continue and create a provisional processing ledger entry only after successful task creation.

5. Build the ClickUp task payload

Use a ClickUp "Create a Task" module. Map these fields:

• Task name: use the first 70 characters of message_text or a template like "Teams: {short_subject}"
• Description: include a short context block:

Source Teams message: {{teams_message_permalink}}
Posted by: {{message_author}}
When: {{message_ts_local}}

Message

{{message_text}}

Attachments: {{attachment_links}}

• List ID: target ClickUp List
• Assignees: optional default or derive from mention in message
• Due date: optional (leave blank or set to a default SLA)
• Custom fields: set any required metadata using field ids (map exact IDs)

Notes on timestamps: ClickUp commonly accepts epoch milliseconds for start/due dates. Use Make.com date functions to convert ISO timestamps to epoch ms if you need to set dates.

6. Attach files or include links

Two options, based on access and requirements:

• Simpler: include links to Teams files in the task description. This avoids file transfer and preserves the original context.
• Full attach: have Make.com fetch the file binary using the Teams connector or a file fetch URL, then upload it to ClickUp as an attachment via ClickUp's API. This requires the Make.com Teams connection to have file-scoped permissions.

Start with links, then add uploads only if the team needs files embedded in ClickUp.

7. Write back the mapping and post the task link to Teams

• After ClickUp returns the created task id and URL, write the mapping to your ledger (message_id → clickup_task_id, processed_at).
• Post a reply in the original Teams thread using the channel/conversation id and message timestamp. The reply should contain the ClickUp task link and a short note, for example: "Task created: Open task (link). If you want a different assignee or due date, edit the task."

Replying in-thread keeps the conversation connected to the task and reduces follow-up questions.

8. Error handling and common gotchas

• File access: Teams file links often require the posting user's permissions. If the Make.com connection cannot fetch a file, include the Teams file link in the ClickUp description instead.
• Duplicate reactions or double-invocations: rely on the ledger lookup to avoid creating multiple tasks for the same message.
• Rate limits: avoid heavy file transfers in high-volume channels; instead use links or batch uploads.
• Permissions: ensure Make.com has both the Teams app permissions to read messages and the ClickUp token to create tasks in the target list.

9. Test a few real-world cases

• Create a task from a plain text message with no attachments.
• Create a task from a message that includes a file link, verify the link appears in ClickUp.
• Re-run the action on the same message to confirm dedupe prevents a new task.
• Verify the reply appears in-thread with a working ClickUp link.

Real-World Business Scenario

A support team used this pattern to convert Slack bug reports into ClickUp tasks; swapping Slack for Teams is the same pattern. Support agents mark a message with the message action, a ClickUp task appears with the full message and screenshot links, and the task link is posted back into the thread for engineers to triage. This removed manual transcription and reduced triage time.

For a similar approach that starts from Slack instead of Teams, see our guide on creating ClickUp tasks from Slack messages How to Create a ClickUp Task from a Slack Message Using Make.com. If you prefer to surface assignment alerts in Teams when ClickUp tasks change, our post about assignment alerts covers that angle too: How to Notify Microsoft Teams When a ClickUp Task Is Assigned Using Make.com.

Common Variations

• Add a short follow-up form: after invoking the message action, ask the user one clarifying question (priority or ETA) via a small Teams card and use that answer to populate a custom field.
• Create tasks in different ClickUp Lists depending on the Teams channel or a keyword in the message.
• Bulk convert: add a small moderator workflow that batches several marked messages into a single project task with subtasks for each message.

Putting this into practice

This pattern turns short, deliberate Teams interactions into tracked work without losing context. It keeps the signal in Teams and the execution in ClickUp, with a small idempotency ledger to prevent duplicates.

If you want this implemented across your channels or extended with file uploads, assignee routing, and adaptive cards for confirmations, Olmec Dynamics builds these exact automations for teams. See how we work at https://olmecdynamics.com.