How to Send Asana Task Notifications to Slack with Pipedream

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and sign in. Click the blue 'New Workflow' button in the top-right of the dashboard. Give the workflow a name like 'Asana → Slack Task Notifications' so it's easy to find later. You'll land on the workflow canvas with an empty trigger slot at the top.

1. 1Click 'New Workflow' in the top-right corner
2. 2Enter the workflow name in the title field at the top of the canvas
3. 3Click the 'Add a trigger' block to open the trigger selection panel

Workflow Canvas > Add a trigger > Asana > Task Updated

Connect Asana as the trigger source

In the trigger selection panel, type 'Asana' in the search box and select it from the list. Pipedream will show you a list of Asana trigger events. Select 'New Task Assigned to Me' or 'Task Updated' depending on whether you want to catch assignments, priority changes, or both. For this workflow, select 'Task Updated' — it fires on both assignment changes and priority changes, which is what you need.

1. 1Type 'Asana' in the trigger search box
2. 2Click 'Asana' in the results list
3. 3Select 'Task Updated' from the event list
4. 4Click 'Connect Account' and authenticate with your Asana credentials
5. 5Select the Asana workspace and project you want to monitor from the dropdowns

Workflow Canvas > Trigger Step > Generate Test Event

Test the Asana trigger with a real event

Click 'Generate Test Event' in the trigger panel. Pipedream will pull the most recent task update from the connected project. If no recent events exist, go to Asana, assign a task to yourself, then return to Pipedream and click 'Generate Test Event' again. Review the raw JSON payload that appears — you'll use fields from this payload in later steps. Pay attention to 'assignee.gid', 'assignee.name', 'name', 'priority', and 'permalink_url'.

1. 1Click 'Generate Test Event' in the trigger configuration panel
2. 2If no events appear, create a test task assignment in Asana and click again
3. 3Expand the returned JSON to see the full event payload
4. 4Note the field paths for assignee name, task name, priority, and task URL

Workflow Canvas > + > Filter

Add a filter step to catch only assignments and priority changes

Click the '+' button below the trigger step to add a new step. Select 'Filter' from the built-in Pipedream actions. You need to stop the workflow from running when irrelevant fields change. Set the filter condition to check whether the event includes a changed assignee or a changed priority custom field. Use Pipedream's expression editor to reference the trigger output.

1. 1Click the '+' step button below the Asana trigger
2. 2Select 'Filter' from the built-in actions list
3. 3Set Condition 1: steps.trigger.event.change.field equals 'assignee'
4. 4Click 'OR' to add a second condition
5. 5Set Condition 2: steps.trigger.event.change.field equals the name of your priority custom field (check your test payload)

Workflow Canvas > + > Run Node.js code

Add a Node.js code step to build the Slack message

Click '+' below the Filter step and select 'Run Node.js code'. This step will read the Asana event data and construct a clean Slack Block Kit message. You'll reference the trigger payload using the 'steps' object. Write the logic to detect whether this is an assignment event or a priority change event, then format the message accordingly. The code in the pro_tip_code section below is ready to paste here.

1. 1Click the '+' step button below the Filter step
2. 2Select 'Run Node.js code' from the step list
3. 3Paste the code from the pro_tip section into the code editor
4. 4Update the priority custom field index to match what you found in Step 3
5. 5Click 'Test' to run the code against your test event and verify the output

Paste this into the Node.js code step between the Filter step and the Slack step. It detects whether the event is an assignment or priority change, resolves the priority custom field by name (not index), formats a Slack Block Kit message, and exports clean variables for the downstream Slack step to reference.

// Pipedream Node.js code step: Build Slack notification from Asana task event
// Place this step AFTER the Filter step and BEFORE the Slack Send Message step
export default defineComponent({

// Pipedream Node.js code step: Build Slack notification from Asana task event
// Place this step AFTER the Filter step and BEFORE the Slack Send Message step

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event;
    const resource = event.resource || {};
    const change = event.change || {};

    // Determine event type
    const changedField = change.field || '';
    const isAssignment = changedField === 'assignee';
    // Priority is a custom field — match by name, not index
    const PRIORITY_FIELD_NAME = 'Priority'; // Update this to match your Asana custom field name

    const priorityField = (resource.custom_fields || []).find(
      (f) => f.name === PRIORITY_FIELD_NAME
    );
    const priorityGid = priorityField?.gid || '';
    const isPriorityChange = changedField === priorityGid;

    if (!isAssignment && !isPriorityChange) {
      $.flow.exit('Event is not an assignment or priority change — skipping');
    }

    // Extract core fields
    const taskName = resource.name || 'Unnamed Task';
    const taskUrl = resource.permalink_url || '';
    const assigneeName = resource.assignee?.name || 'Unassigned';
    const assigneeEmail = resource.assignee?.email || null;
    const projectName = resource.memberships?.[0]?.project?.name || 'Unknown Project';
    const dueOn = resource.due_on
      ? new Date(resource.due_on).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
      : 'No due date';
    const priorityDisplay = priorityField?.display_value || 'None';

    // Build message text and Slack Block Kit payload
    const eventLabel = isAssignment
      ? `📋 *New task assigned to ${assigneeName}*`
      : `🔴 *Priority changed to ${priorityDisplay} — ${assigneeName}*`;

    const blocks = [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: eventLabel,
        },
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Task:*\n${taskName}` },
          { type: 'mrkdwn', text: `*Project:*\n${projectName}` },
          { type: 'mrkdwn', text: `*Priority:*\n${priorityDisplay}` },
          { type: 'mrkdwn', text: `*Due:*\n${dueOn}` },
        ],
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: 'Open in Asana' },
            url: taskUrl,
          },
        ],
      },
    ];

    return {
      eventType: isAssignment ? 'assigned' : 'priority_changed',
      assigneeName,
      assigneeEmail,
      taskName,
      taskUrl,
      projectName,
      priorityDisplay,
      dueOn,
      message: `${eventLabel}\n*Task:* ${taskName}\n*Project:* ${projectName}\n*Priority:* ${priorityDisplay}\n*Due:* ${dueOn}\n<${taskUrl}|Open in Asana>`,
      blocks: JSON.stringify(blocks),
    };
  },
});

Workflow Canvas > + > Slack > Send Message to a Public Channel

Connect Slack and configure the Send Message action

Click '+' below the code step and search for 'Slack'. Select the 'Send Message to a Public Channel' action (or 'Send a Direct Message' if you want to DM the assignee instead of posting to a channel). Connect your Slack workspace via the 'Connect Account' button — this uses OAuth and takes about 30 seconds. Select the destination channel from the dropdown, or set it dynamically using the assignee's Slack user ID if you're routing to DMs.

1. 1Click '+' and search for 'Slack'
2. 2Select 'Send Message to a Public Channel' or 'Send a Direct Message'
3. 3Click 'Connect Account' and authorize Pipedream in the Slack OAuth flow
4. 4Select the target channel (e.g., #task-notifications) from the Channel dropdown
5. 5In the 'Message Text' field, reference steps.build_message.message from your code step

Workflow Canvas > Slack Step > Message Text

Map Asana fields to the Slack message

In the Slack step's Message Text field, reference the output from your Node.js code step. Use Pipedream's expression syntax to pull in the formatted message. If you want to use Slack Block Kit for richer formatting (buttons, sections, bold text), switch the Message field to 'Blocks' mode and paste your Block Kit JSON — the pro_tip code generates this for you. Test the step to confirm the message renders correctly in Slack.

1. 1Click inside the 'Message Text' field in the Slack step
2. 2Type '{{' to open the expression picker
3. 3Select 'steps.build_message.$return_value.message' from the dropdown
4. 4Optionally switch to 'Blocks' mode and paste the Block Kit JSON from your code step
5. 5Click 'Test' to send a real message to your Slack channel

Workflow Canvas > + (before Slack step) > Run Node.js code

Handle DM routing by resolving Slack user from Asana assignee

If you want to DM the assignee directly instead of posting to a channel, you need to match the Asana assignee email to a Slack user ID. Add a second Node.js code step before the Slack step. Call the Slack 'users.lookupByEmail' API using the assignee's email from the Asana payload. Store the returned Slack user ID and pass it to the Slack 'Send a Direct Message' action as the recipient. Skip this step entirely if you're posting to a channel.

1. 1Click '+' between your message-building code step and the Slack step
2. 2Select 'Run Node.js code'
3. 3Write a fetch call to https://slack.com/api/users.lookupByEmail with the Asana assignee email
4. 4Export the Slack user ID as the return value
5. 5In the Slack 'Send a Direct Message' step, set the recipient to steps.lookup_slack_user.$return_value.userId

Workflow Canvas > Settings (right panel) > Error Handling

Add error handling with Pipedream's on_error step

In the workflow settings panel on the right side, click 'Error Handling'. Set the workflow to send you an email or Slack message if any step throws an uncaught error. This protects you from silent failures where Asana fires the webhook but the Slack message never sends. Alternatively, wrap your code steps in try/catch blocks and use $.flow.exit() to stop cleanly with a log message when expected errors occur (like missing assignee data).

1. 1Click the gear icon or 'Settings' tab in the right panel of the workflow canvas
2. 2Scroll to 'Error Handling'
3. 3Enable 'Send error notifications' and enter your email or a Slack webhook URL
4. 4Set the retry policy to 1 retry with a 30-second delay
5. 5Click 'Save Settings'

Workflow Canvas > Deploy (top-right button)

Deploy and verify the live webhook

Click the green 'Deploy' button in the top-right of the workflow canvas. Pipedream will activate the workflow and display the live webhook URL for the Asana trigger. Copy this URL — you do not need to paste it anywhere manually because Pipedream's Asana trigger manages the webhook subscription automatically. Go to Asana and assign a real task to a team member. The Slack message should appear within 10 seconds.

1. 1Click the green 'Deploy' button in the top-right corner
2. 2Wait for the deployment confirmation banner
3. 3Go to Asana and assign a task in the monitored project
4. 4Check the target Slack channel or DM for the notification
5. 5Return to Pipedream and check the 'Events' tab to confirm the event was received and processed