How to Create Wrike Tasks from Slack Messages with Pipedream

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and sign in. Click 'New Workflow' in the top-right corner of the dashboard. You'll land on the workflow canvas with an empty trigger slot at the top. Give the workflow a name like 'Slack Emoji → Wrike Task' using the pencil icon at the top — this makes it easier to find later when you have multiple workflows running.

1. 1Sign in at pipedream.com
2. 2Click 'New Workflow' in the top-right
3. 3Click the pencil icon next to the default workflow name
4. 4Type 'Slack Emoji → Wrike Task' and press Enter

Workflow Canvas > Add Trigger > Slack > New Reaction Added to a Message

Add the Slack trigger: New Reaction Added

Click 'Add Trigger' and search for 'Slack'. Select the Slack app, then choose the trigger 'New Reaction Added to a Message'. This trigger fires instantly via Slack's Events API webhook — not polling — so task creation happens within 2-3 seconds of the emoji being added. Connect your Slack account via the 'Connect Account' button, which will open an OAuth window.

1. 1Click 'Add Trigger'
2. 2Type 'Slack' in the search box and select the Slack app
3. 3Choose 'New Reaction Added to a Message' from the trigger list
4. 4Click 'Connect Account' and complete the Slack OAuth flow
5. 5Set the 'Reaction' field to 'white_check_mark' (or whichever emoji your team has agreed on)

Workflow Canvas > Trigger Step > Test Trigger

Test the Slack trigger

Click 'Test Trigger'. Pipedream will instruct you to go to Slack and add your chosen reaction to any message. Do it now — open Slack in another tab, react to a message with the emoji you configured, then come back. Pipedream will capture the event payload within a few seconds and display it in the trigger output panel on the right side of the canvas.

1. 1Click 'Test Trigger'
2. 2Switch to Slack and add the configured emoji reaction to any message
3. 3Return to Pipedream and wait for the event to appear in the right panel
4. 4Expand the payload to confirm fields like 'reaction', 'item.channel', and 'item.ts' are present

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

Fetch the full Slack message text

Add a Node.js code step after the trigger. The trigger payload only contains metadata — you need to call Slack's conversations.history API to retrieve the actual message text using the channel ID and timestamp from the trigger. Use Pipedream's built-in Slack app authentication so you don't have to manage tokens manually. This step outputs the message text, author name, and channel name for use in the Wrike task.

1. 1Click the '+' button below the trigger step
2. 2Select 'Run Node.js code'
3. 3Paste the code from the Pro Tip section below into the code editor
4. 4Reference the trigger outputs using 'steps.trigger.event.item.channel' and 'steps.trigger.event.item.ts'

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

Parse the message for task details

Add a second Node.js code step to extract structured data from the message text. Your team should agree on a format — for example: '@assign:jane.doe due:2024-03-15 Fix login button on mobile'. This step uses a regex to pull out the assignee, due date, and task title from the raw message text. If no assignee or due date is found, defaults are applied so the task still gets created.

1. 1Click '+' below the fetch step
2. 2Select 'Run Node.js code'
3. 3Write or paste your parsing logic targeting 'steps.fetch_message.$return_value.messageText'
4. 4Export the parsed fields: title, assigneeEmail, dueDate

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

Look up the Wrike user ID by email

Wrike tasks require an assignee user ID, not an email address. Add another Node.js code step that calls Wrike's /contacts API endpoint to resolve the email from the previous step into a Wrike user ID. This is a required lookup — Wrike's task creation endpoint will reject a raw email string. Cache the result in the step output so the next step can reference it directly.

1. 1Click '+' to add a new code step
2. 2Call GET https://www.wrike.com/api/v4/contacts?me=false using your Wrike API token
3. 3Filter the response array for a contact where 'profiles[0].email' matches the parsed assignee email
4. 4Return the matched contact's 'id' field as 'wrikeUserId'

Workflow Canvas > + Add Step > Wrike > Connect Account

Connect your Wrike account

Add a Wrike app step by clicking '+' and searching for 'Wrike'. Before configuring the action, connect your Wrike account. Click 'Connect Account' in the Wrike step and complete the OAuth flow — Wrike will ask you to authorize access to your workspace. You only do this once; Pipedream stores the credential in Connected Accounts for reuse.

1. 1Click '+' and search for 'Wrike'
2. 2Select 'Wrike' from the app list
3. 3Click 'Connect Account'
4. 4Complete the Wrike OAuth authorization in the popup window

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

Create the Wrike task

Use a Node.js code step (rather than the pre-built Wrike action) to call POST /tasks on Wrike's v4 API. This gives you full control over the payload including custom fields, folder targeting, and assignee IDs. Set the task title from the parsed message, the due date from the parsed date field, and the assignee from the user ID lookup. Set the status to 'Active' so it appears immediately on the board.

1. 1Click '+' and select 'Run Node.js code'
2. 2Use the Wrike connected account's OAuth token via the $ helper or hardcode via environment variable
3. 3POST to https://www.wrike.com/api/v4/folders/{folderId}/tasks with your task payload
4. 4Include 'title', 'assignees', 'dates.due', and 'status' in the request body

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

Post a confirmation back to Slack

Add a final Node.js code step that posts a reply in the same Slack thread using chat.postMessage. Include the Wrike task URL so the team member can click straight through. This closes the loop — the person who flagged the message gets confirmation the task was captured, and the thread stays as a record. Use 'thread_ts' set to the original message timestamp so the reply stays threaded.

1. 1Click '+' and add a final code step
2. 2Call Slack's chat.postMessage with 'channel' and 'thread_ts' from the trigger payload
3. 3Set the message text to include the Wrike task title and task permalink
4. 4Use your Slack connected account's bot token from the $ auth helper

Workflow Canvas > Deploy > Runs tab

Deploy and test end-to-end

Click 'Deploy' in the top-right corner of the Pipedream canvas. The workflow is now live and listening. Go to Slack, find any message, and add your trigger emoji. Watch the Pipedream execution log in real time under the 'Runs' tab — you'll see each step turn green as it completes. Confirm the task appears in Wrike and the threaded Slack reply arrives.

1. 1Click 'Deploy' in the top-right corner
2. 2Switch to Slack and react to a real message with the trigger emoji
3. 3Return to Pipedream and click the 'Runs' tab
4. 4Click on the latest run to inspect each step's input and output
5. 5Open Wrike and confirm the task exists in the target folder

This code handles four things in one step: fetches the full Slack message text via conversations.history, parses the assignee email and due date using regex, resolves the Wrike user ID via the contacts API, and creates the Wrike task — with error handling at each stage. Paste this into a single Node.js code step after the Slack trigger, replacing the four separate code steps if you want a more compact workflow.

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

import axios from 'axios';

export default defineComponent({
  props: {
    slack: {
      type: 'app',
      app: 'slack',
    },
    wrike: {
      type: 'app',
      app: 'wrike',
    },
  },
  async run({ steps, $ }) {
    const WRIKE_FOLDER_ID = process.env.WRIKE_FOLDER_ID; // Set in Pipedream env vars
    const channel = steps.trigger.event.item.channel;
    const messageTs = steps.trigger.event.item.ts;

    // Step 1: Fetch the full Slack message text
    const historyRes = await axios({
      method: 'GET',
      url: 'https://slack.com/api/conversations.history',
      headers: { Authorization: `Bearer ${this.slack.$auth.oauth_access_token}` },
      params: { channel, latest: messageTs, limit: 1, inclusive: true },
      timeout: 10000,
    });

    if (!historyRes.data.ok) {
      throw new Error(`Slack API error: ${historyRes.data.error}`);
    }

    const message = historyRes.data.messages[0];
    if (!message) throw new Error('Message not found in Slack history');
    const rawText = message.text;

    // Step 2: Parse assignee email and due date from message
    const assigneeMatch = rawText.match(/@assign:([\w.+-]+@[\w.-]+\.[a-z]{2,})/i);
    const dueDateMatch = rawText.match(/due:(\d{4}-\d{2}-\d{2})/);
    const assigneeEmail = assigneeMatch ? assigneeMatch[1] : null;
    const dueDate = dueDateMatch ? dueDateMatch[1] : null;
    const taskTitle = rawText
      .replace(/@assign:[\w.+-]+@[\w.-]+\.[a-z]{2,}/gi, '')
      .replace(/due:\d{4}-\d{2}-\d{2}/g, '')
      .trim();

    // Step 3: Resolve Wrike user ID from email (skip if no assignee)
    let wrikeUserId = null;
    if (assigneeEmail) {
      const contactsRes = await axios({
        method: 'GET',
        url: 'https://www.wrike.com/api/v4/contacts',
        headers: { Authorization: `Bearer ${this.wrike.$auth.oauth_access_token}` },
        timeout: 15000,
      });
      const contacts = contactsRes.data.data || [];
      const match = contacts.find(
        (c) => c.profiles && c.profiles.some((p) => p.email === assigneeEmail)
      );
      if (match) {
        wrikeUserId = match.id;
      } else {
        console.log(`No Wrike user found for email: ${assigneeEmail} — creating unassigned`);
      }
    }

    // Step 4: Build Wrike task payload
    const taskPayload = {
      title: taskTitle || 'Untitled task from Slack',
      status: 'Active',
      description: `From Slack channel ${channel} | Original message: ${rawText}`,
      ...(wrikeUserId && { assignees: [wrikeUserId] }),
      ...(dueDate && { dates: { type: 'Planned', due: dueDate } }),
    };

    // Step 5: Create the Wrike task
    const taskRes = await axios({
      method: 'POST',
      url: `https://www.wrike.com/api/v4/folders/${WRIKE_FOLDER_ID}/tasks`,
      headers: {
        Authorization: `Bearer ${this.wrike.$auth.oauth_access_token}`,
        'Content-Type': 'application/json',
      },
      data: taskPayload,
      timeout: 15000,
    });

    const createdTask = taskRes.data.data[0];
    console.log(`Wrike task created: ${createdTask.id} — ${createdTask.title}`);

    // Step 6: Post confirmation back to Slack thread
    await axios({
      method: 'POST',
      url: 'https://slack.com/api/chat.postMessage',
      headers: { Authorization: `Bearer ${this.slack.$auth.oauth_access_token}` },
      data: {
        channel,
        thread_ts: messageTs,
        text: `✅ Wrike task created: *${createdTask.title}* — <${createdTask.permalink}|Open in Wrike>`,
      },
    });

    return {
      taskId: createdTask.id,
      taskTitle: createdTask.title,
      assigneeEmail,
      dueDate,
      wrikeUserId,
    };
  },
});