Automatically create ClickUp tasks from starred Gmail messages using Make.com, then post an Adaptive Card to Microsoft Teams with the task link and context.

Introduction

You star an email because it needs follow-up, then someone has to copy the subject, paste the snippet into ClickUp, set a due date, and tell the team in Teams. That manual handoff loses context and creates delays.

This guide shows a compact Make.com scenario that reacts when you star a Gmail message: it creates a ClickUp task with the right title and description, then posts an Adaptive Card into a Microsoft Teams channel. By the end you will have the exact modules, field mappings, and the small gotchas to watch for.

What you will know by the end: how to watch starred Gmail messages in Make.com, map message fields into ClickUp task fields, and post a Teams Adaptive Card containing the ClickUp link.

What You'll Need

A Gmail account connected in Make.com (OAuth scopes for mail read and labels). If you rely on Gmail watch via Pub/Sub, you need a Google Cloud Pub/Sub topic and setup.
A ClickUp account able to create tasks in the target List, plus a ClickUp API token or a connected ClickUp app inside Make.com.
A Microsoft Teams Incoming Webhook for the channel you will notify, or a Teams connector in Make.com that accepts Adaptive Card JSON.
A Make.com account with Gmail, ClickUp, and HTTP/Teams modules available. For reliable polling use a paid Make.com plan if your volume or latency needs require it.

Permissions notes: ClickUp custom fields often require numeric IDs. If you set custom fields, capture their IDs beforehand.

How It Works (The Logic)

Trigger: a Gmail message is starred. Make.com picks up the message, extracts subject, sender, snippet, message ID and a permalink if available. Make.com creates a ClickUp task in your chosen List with a composed title and a description that includes the message context and a reference to the Gmail message ID. Make.com then posts an Adaptive Card to a Teams channel with the task name and a link back to ClickUp.

In plain flow: Gmail (starred) 12 Make.com reads message 12 Create ClickUp task 12 Post Adaptive Card to Teams

Step-by-Step Setup

Pick your Gmail trigger and scope

In Make.com create a new Scenario and add the Gmail module "Watch Emails".
Restrict the trigger to the STARRED label or use the search query is:starred. This avoids scanning your whole inbox.
For predictable behaviour, instruct users to star a message only when it should generate a ClickUp task rather than using stars as a general bookmark.

Gotcha: Make.com polling cadence matters. If you need near-instant creation, set a short polling interval supported by your plan; otherwise, expect a small delay.

Inspect a sample starred message in Make.com

Run the trigger in test mode and star a real email to capture a sample payload.
Confirm the trigger returns these fields at minimum: message id, thread id, subject, from (name and email), snippet or body preview, labels array, and internal timestamp.

Tip: If your trigger does not return a permalink, you can construct one using Gmail web interface patterns, but include message id in the task description as a reliable reference.

Add ClickUp: Create Task module

Add the ClickUp module "Create a Task" and select the target Workspace, Space, Folder and List.
Map fields:
- Task name: Gmail: {{subject}} 12 {{from_name}}
- Description: include a short block with context. Example:
  
  Source: Gmail (starred)
  From: {{from_name}} <{{from_email}}>
  Received: {{received_date_local}}
  Snippet: {{snippet}}
  Message ID: {{message_id}}
- Assignees: optional (use a default assignee or leave blank)
- Due date: optional, map from a rule (for example, add 3 business days) if you want an SLA
- Tags or custom fields: optional, for example add a tag email-followup

Field format notes: ClickUp typically accepts due dates as epoch milliseconds in API calls. Use Make.com date functions to produce epoch ms (for example convert ISO to epoch ms) if you set due dates.

Common gotcha: if your ClickUp connector returns only a task ID, construct the ClickUp URL like https://app.clickup.com/t/{{task_id}} and save it.

Optional dedupe check (recommended)

Add a lightweight dedupe guard so repeated starring or retries do not create duplicate tasks.
Options:
- Search ClickUp in the target List for the Message ID text in the description before creating a task, or
- Keep a small Google Sheets or Make.com Data Store log keyed by Gmail message id.

If a record exists, route to a branch that posts a Teams message saying "task already exists" or update the existing task instead of creating a new one.

Post to Microsoft Teams with an Adaptive Card

Create an Incoming Webhook in Teams for the channel you want to notify. Copy the webhook URL.
Add an HTTP module in Make.com, method POST, URL set to the Teams webhook URL, header Content-Type: application/json.
Build a compact Adaptive Card payload. Minimal example:

{ "type": "AdaptiveCard", "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", "version": "1.2", "body": [ { "type": "TextBlock", "text": "New ClickUp task created from a starred email", "weight": "Bolder", "size": "Medium" }, { "type": "TextBlock", "text": "Task: {{task_name}}", "wrap": true }, { "type": "TextBlock", "text": "From: {{from_name}} <{{from_email}}> 12 {{received_date_local}}", "wrap": true }, { "type": "TextBlock", "text": "Snippet: {{snippet}}", "wrap": true }, { "type": "TextBlock", "text": "<{{task_url}}|Open ClickUp task>", "wrap": true } ] }

Replace the placeholders with data pills from the ClickUp create step (task_name, task_url) and Gmail fields (from_name, snippet). Teams will render the card and show the link.

Action button note: Teams supports Action.OpenUrl in Adaptive Cards. If you want a button instead of a link, include an action block with the ClickUp URL.

Test the full flow

Star a real email and watch the Make.com run.
Confirm a task appears in ClickUp with the mapped name and description.
Confirm Teams receives an Adaptive Card with the ClickUp link and readable context.
Test the dedupe path: star the same message again or re-trigger the scenario to ensure duplicates are avoided.

Turn on and monitor

Activate the scenario and check runs for the first few days. Look for timezone issues in the received date, missing sender email for internal messages, or ClickUp API rate-limit errors.
Add a simple failure branch that writes the raw payload and error message to a Google Sheet or posts a short Teams alert to an ops channel for manual review.

Real-World Business Scenario

A small services team uses the star method as their lightweight intake: the account lead stars emails that require action and the ops person picks up starred messages every hour. After automating, each starred email became a ClickUp task with the sender, snippet and a reference message ID. The Teams channel for the ops team receives a small Adaptive Card so the whole group sees new follow-ups without opening ClickUp. The manual copy-paste step disappeared overnight.

Common Variations

Auto-assign by sender domain: map certain sender domains to specific ClickUp assignees using a small Google Sheets lookup table and set ClickUp assignees accordingly.
Create a due date from email content: use a simple date-extraction rule (for example, look for "by Friday") to set a provisional due date, otherwise leave it blank.
Threaded follow-ups: when a ClickUp task is completed, post a short Teams update into the same channel to close the loop. For ClickUp 12 Teams assignment or status alerts see our post on notifying Teams from ClickUp How to Notify Microsoft Teams When a ClickUp Task Is Assigned Using Make.com.

Bringing related patterns together

If your team also turns chat messages into tasks, the same ClickUp create pattern works from Slack or Teams. See our guide on converting Slack messages to ClickUp tasks How to Create a ClickUp Task from a Slack Message Using Make.com for the identical downstream ClickUp mappings and user experience advice.

Keeping the workflow small, explicit, and anchored to a single action (star the message) makes it reliable and easy for users to adopt.

Putting this into practice

You now have a compact Make.com scenario blueprint that converts starred Gmail messages into ClickUp tasks and notifies your team in Microsoft Teams with an Adaptive Card. If you want Olmec Dynamics to implement this across your Gmail domain, ClickUp lists, and Teams channels, we build and operate these automations for real teams. See what we do at https://olmecdynamics.com

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