How to Sync Asana Sprints to Slack with Pipedream

pipedream.com > Dashboard > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and sign in. Click 'New Workflow' in the top-left dashboard. You'll land on the workflow canvas with an empty trigger slot at the top. Give the workflow a name like 'Asana Sprint → Slack' using the pencil icon next to 'Untitled Workflow' at the top of the page. This name shows up in logs and is worth setting before you forget.

1. 1Click 'New Workflow' in the left sidebar
2. 2Click the pencil icon next to 'Untitled Workflow' and type 'Asana Sprint → Slack'
3. 3Click the '+ Add Trigger' block at the top of the canvas

Workflow Canvas > Add Trigger > Asana > New Story (Instant)

Set Asana webhook as the trigger

In the trigger selector, search for 'Asana' and select it. Choose the trigger type 'New Story (Instant)' — this fires on any Asana activity event including task updates, section moves, and custom field changes, which covers sprint start, blocker, and completion events. Connect your Asana account via Connected Accounts when prompted. Pipedream generates a webhook URL immediately and registers it with Asana's Events API automatically — you don't need to touch the Asana API console.

1. 1Type 'Asana' in the trigger search box
2. 2Select 'New Story (Instant)' from the trigger list
3. 3Click 'Connect Asana Account' and authenticate via OAuth
4. 4Select your target Asana workspace from the dropdown
5. 5Select the specific Asana project that contains your sprints

Workflow Canvas > Trigger > Events Tab

Send a test event from Asana

Open Asana in a new tab and navigate to the project you selected. Move a task to a new section, or add a comment. Return to Pipedream — you should see an event appear under the trigger's 'Events' tab within 15 seconds. Click the event to expand it and inspect the raw payload. You need to confirm the shape of the data before writing transformation logic. Pay attention to the 'type' and 'resource.resource_type' fields — these tell you whether the event is a task move, a comment, or a custom field change.

1. 1Open Asana and move a task between sections in your sprint project
2. 2Return to Pipedream and click the 'Events' tab on the trigger block
3. 3Click the incoming event to expand its JSON payload
4. 4Note the values of 'type', 'resource.resource_type', and 'resource.gid'

Workflow Canvas > + Add Step > Run Node.js Code

Add a Node.js step to classify the sprint event

Click '+ Add a Step' below the trigger and choose 'Run Node.js code'. This step reads the Asana event payload and classifies it as a sprint start, completion, blocker, or ignorable event. Use the $ object to access trigger output via steps.trigger.event. Write a switch or if/else block based on the task's section name or custom field value. Return a structured object — event_type, project_name, task_name, assignee, due_date — so the next step can build the Slack message cleanly.

1. 1Click '+ Add a Step' below the trigger block
2. 2Select 'Run Node.js code' from the step type list
3. 3Paste your classification logic into the code editor
4. 4Click 'Test' to run the step against the sample event you captured

Workflow Canvas > Node.js Code Step > Code Editor

Fetch full task details from Asana API

Inside the same Node.js step (or a second one), use Pipedream's built-in @pipedream/platform axios or the native fetch to call Asana's Tasks API: GET https://app.asana.com/api/1.0/tasks/{task_gid}?opt_fields=name,assignee.name,due_on,memberships.section.name,custom_fields. Pass your Asana OAuth token from the connected account using auths.asana.oauth_access_token. Extract the section name to determine sprint boundary — teams typically name sections 'Sprint 12 - Active' or 'Done'.

1. 1Add an import or require for axios at the top of the code step
2. 2Build the API URL using the resource GID from steps.trigger.event.resource.gid
3. 3Set the Authorization header to 'Bearer ' + auths.asana.oauth_access_token
4. 4Parse the response and extract name, assignee.name, due_on, and memberships[0].section.name

Workflow Canvas > + Add Step > Run Node.js Code

Add conditional logic to route by event type

Add another Node.js step to decide which Slack message template to use based on event_type. Sprint starts get a summary block with team capacity and task count. Completions get a recap with completed vs. incomplete ratio. Blockers get an urgent-formatted message with the assignee tagged. Return a message object with the text, channel name, and any Block Kit JSON you want. Keeping routing logic in its own step makes it easier to debug — you can test each branch independently.

1. 1Click '+ Add a Step' below the previous code step
2. 2Select 'Run Node.js code'
3. 3Reference the classification output using steps.classify.$return_value.event_type
4. 4Build a switch statement with cases for sprint_start, sprint_complete, and blocker
5. 5Return a message object with fields: channel, text, blocks (optional)

Workflow Canvas > + Add Step > Run Node.js Code

Add Asana project summary lookup for sprint start messages

Sprint start messages need aggregate data — how many tasks are in the sprint, who is assigned to what, and total story points if you use them. Add a Node.js step that calls GET https://app.asana.com/api/1.0/projects/{project_gid}/tasks?opt_fields=assignee.name,custom_fields,completed to pull all tasks in the active section. Count them, group by assignee, and sum any custom field used for story points. This data populates the capacity block in the Slack message.

1. 1Add a new Node.js step after the routing step
2. 2Call the Asana Projects Tasks API with the project GID from your trigger
3. 3Filter the response to only tasks in the active sprint section
4. 4Group tasks by assignee.name and count per person
5. 5Return an object with total_tasks, by_assignee array, and total_points

Workflow Canvas > + Add Step > Slack > Send Message

Connect Slack and send the message

Click '+ Add a Step', search for 'Slack', and select the 'Send Message' action. Connect your Slack workspace via Connected Accounts. Set the Channel field to reference steps.route.$return_value.channel — this lets you dynamically route blockers to #sprint-blockers and summaries to #sprint-updates from the same workflow. Set the Text field to steps.route.$return_value.text. If you built Block Kit JSON in the routing step, paste it into the Blocks field.

1. 1Click '+ Add a Step' and search for 'Slack'
2. 2Select the 'Send Message' action
3. 3Click 'Connect Slack Account' and authorize with your workspace
4. 4Set Channel to {{steps.route.$return_value.channel}}
5. 5Set Text to {{steps.route.$return_value.text}}
6. 6Optionally set Blocks to {{steps.route.$return_value.blocks}} for rich formatting

Workflow Canvas > Workflow Settings > Error Handling

Add error handling and dead-letter logging

Wrap your API calls in try/catch blocks and use $.flow.exit('reason') to halt execution cleanly when the event is not sprint-relevant — like a comment or a like. For genuine errors (API timeouts, auth failures), use console.error() to log context and re-throw so Pipedream marks the execution as failed. This gives you a filterable error log in the Pipedream dashboard. Set up an error notification in Pipedream's workflow settings to email or Slack yourself on failures.

1. 1Wrap all fetch/axios calls in try/catch in each code step
2. 2Use $.flow.exit('not a sprint event') for ignorable events
3. 3Add console.error(error.message, error.response?.data) in catch blocks
4. 4Click 'Settings' (gear icon) on the workflow and enable 'Send error notifications'
5. 5Set the error notification destination to a Slack channel or email

Workflow Canvas > Deploy > Executions Tab

Deploy and test all three event types

Click 'Deploy' in the top right to activate the workflow. In Asana, manually simulate each event type: move a task into your sprint's active section (sprint start), move one to Done (completion), and add a custom field value indicating a blocker. Check Slack after each action — messages should arrive within 15 seconds. Check the Pipedream executions log to confirm each run completed without errors and that the event_type classification matched what you expected.

1. 1Click 'Deploy' in the top right corner of the workflow canvas
2. 2Open Asana and move a task into the active sprint section
3. 3Check #sprint-updates in Slack for the sprint start message
4. 4Move a different task to your 'Done' section and confirm the completion message
5. 5Set a blocker custom field on a task and confirm the urgent message in #sprint-blockers

Workflow Canvas > Trigger Step > Filters Tab

Set event filters to suppress noise

Go back to the trigger step and click 'Add filter'. Add a filter rule that only passes events where resource.resource_type equals 'task'. This immediately drops comment events and like events before they reach your code steps, cutting your execution count and cost. You can add additional filters — like requiring the project GID to match a specific value — if multiple Asana projects are in the same workspace and you only want sprint events from one of them.

1. 1Click the trigger step to expand its configuration
2. 2Click the 'Filters' tab
3. 3Click 'Add Filter' and set field to 'resource.resource_type'
4. 4Set operator to 'equals' and value to 'task'
5. 5Click 'Save' and re-deploy the workflow

Paste this into the classification and task-fetch Node.js step (step 4). It handles the secondary Asana API call to get full task details, classifies the sprint event, assembles the capacity summary for sprint starts, and returns a clean object for the routing step to consume. Replace SPRINT_SECTION_PREFIX with whatever prefix your team uses for active sprint sections — e.g., 'Sprint' or 'Q1-'.

import axios from 'axios';
export default defineComponent({
  props: {

import axios from 'axios';

export default defineComponent({
  props: {
    asana: {
      type: 'app',
      app: 'asana',
    },
  },
  async run({ steps, $ }) {
    const event = steps.trigger.event;

    // Drop non-task events immediately
    if (event.resource?.resource_type !== 'task') {
      $.flow.exit('Not a task event — skipping');
    }

    const taskGid = event.resource.gid;
    const token = this.asana.$auth.oauth_access_token;
    const SPRINT_SECTION_PREFIX = 'Sprint';
    const BLOCKER_FIELD_NAME = 'Blocked';
    const POINTS_FIELD_NAME = 'Story Points';

    // Fetch full task details from Asana
    let task;
    try {
      const res = await axios({
        method: 'GET',
        url: `https://app.asana.com/api/1.0/tasks/${taskGid}`,
        params: {
          opt_fields: [
            'name',
            'assignee.name',
            'assignee.email',
            'due_on',
            'permalink_url',
            'memberships.section.name',
            'memberships.project.name',
            'memberships.project.gid',
            'custom_fields.name',
            'custom_fields.number_value',
            'custom_fields.enum_value.name',
          ].join(','),
        },
        headers: { Authorization: `Bearer ${token}` },
      });
      task = res.data.data;
    } catch (err) {
      console.error('Failed to fetch task:', err.response?.data || err.message);
      throw new Error(`Asana task fetch failed for GID ${taskGid}`);
    }

    const sectionName = task.memberships?.[0]?.section?.name ?? '';
    const projectName = task.memberships?.[0]?.project?.name ?? 'Unknown Project';
    const projectGid = task.memberships?.[0]?.project?.gid;

    // Classify the event
    const blockerField = task.custom_fields?.find(f => f.name === BLOCKER_FIELD_NAME);
    const isBlocked = blockerField?.enum_value?.name === 'Yes';
    const isDone = sectionName.toLowerCase().includes('done') || sectionName.toLowerCase().includes('complete');
    const isActive = sectionName.startsWith(SPRINT_SECTION_PREFIX) && !isDone;

    let eventType;
    if (isBlocked) eventType = 'blocker';
    else if (isDone) eventType = 'sprint_complete';
    else if (isActive) eventType = 'sprint_start';
    else {
      $.flow.exit(`Section '${sectionName}' is not a recognized sprint section — skipping`);
    }

    // For sprint start events, fetch aggregate capacity data
    let capacityData = null;
    if (eventType === 'sprint_start' && projectGid) {
      const allTasks = [];
      let offset = null;
      do {
        const params = {
          project: projectGid,
          opt_fields: 'assignee.name,custom_fields.name,custom_fields.number_value,completed',
          limit: 100,
        };
        if (offset) params.offset = offset;
        const pageRes = await axios({
          method: 'GET',
          url: 'https://app.asana.com/api/1.0/tasks',
          params,
          headers: { Authorization: `Bearer ${token}` },
        });
        allTasks.push(...pageRes.data.data);
        offset = pageRes.data.next_page?.offset ?? null;
      } while (offset);

      const activeTasks = allTasks.filter(t => !t.completed);
      const byAssignee = activeTasks.reduce((acc, t) => {
        const name = t.assignee?.name ?? 'Unassigned';
        acc[name] = (acc[name] ?? 0) + 1;
        return acc;
      }, {});
      const totalPoints = activeTasks.reduce((sum, t) => {
        const pf = t.custom_fields?.find(f => f.name === POINTS_FIELD_NAME);
        return sum + (pf?.number_value ?? 0);
      }, 0);

      capacityData = {
        total_tasks: activeTasks.length,
        total_points: totalPoints,
        by_assignee: Object.entries(byAssignee).map(([name, count]) => ({ name, count })),
      };
    }

    return {
      event_type: eventType,
      task_name: task.name,
      assignee_name: task.assignee?.name ?? 'Unassigned',
      assignee_email: task.assignee?.email ?? null,
      due_date: task.due_on ?? null,
      section_name: sectionName,
      project_name: projectName,
      permalink: task.permalink_url,
      capacity: capacityData,
    };
  },
});