Asana Make integrationAutomate Asana with Make.

Pulls a batch of tasks from a workspace, a project, a tag or one assignee, one bundle per task.

A trigger or a search often hands you nothing more than a task's ID. This module reads the whole task from that ID, so the next steps work with real content instead of a bare number.

Turns an event from any app into work in Asana: a form reply, a support email or a signed quote becomes a task, or a subtask under an existing one.

Keeps a task in step with what happens outside Asana, without anyone editing it by hand.

Removes a task for good, which helps clean up duplicates an automation created by mistake.

Copies a model task so recurring work starts from a ready-made version instead of a blank one. The person who picks it up finds the same wording every time, and nobody rebuilds the checklist from memory.

Hands back every subtask sitting under one parent, so you can check progress piece by piece.

Moves a task under another parent, turning a loose task into a subtask or regrouping pieces of work.

Decides who gets notified about a task, adding or removing followers without anyone clicking through Asana. The right people hear about changes, and the others stop getting pinged.

Tells you which projects a task belongs to, one bundle per project, since one Asana task can live in several. That answer lets the rest of the scenario send the task to the right place.

Places an existing task in a project, and even in a chosen section of it, without creating a copy. The same task simply shows up in one more place, so updates stay in one spot.

Takes a task out of one project while it stays alive elsewhere.

Shows which tasks must finish before this one can start, one bundle per blocking task. You see what is holding the work back without opening Asana.

Sets what a task waits on, so the order of work is written into Asana instead of living in someone's head.

The reverse view: every task that is waiting on this one, one bundle each. When something slips, you know straight away who else is affected downstream.

Declares which tasks cannot move until this one is done, from the blocking task's side. Handy when the task holding everything up is the one your scenario already has in hand.

Returns your projects as separate bundles, the starting point for any portfolio-wide check.

Reads the details of one project from its ID, so later modules can reuse what it returns. Your messages and reports then name the project properly instead of showing a code.

Opens a new, empty project from an outside event.

Changes a project's settings when something shifts in another system, so Asana stays in line with the tool your team treats as the reference.

Wipes out an entire project, tasks included.

Clones a template project so every new engagement starts with the same sections and tasks. Nobody forgets a step, and each client gets the same careful setup.

Gives you the number of tasks in a project, a quick health indicator without listing them all. One module, one run, one number to drop into a report.

Returns the columns or headers of a project, one bundle each. It is how your scenario learns the IDs it needs before it files tasks anywhere.

Reads a single section when you already hold its ID. A quick check that saves your scenario from filing tasks into a column someone renamed or removed.

Adds a new section to a project, which on a board shows up as a column. Your structure grows with your process, without anyone setting it up by hand.

Renames a section to match how your process evolves. The tasks inside stay where they are; only the label your team reads changes.

Reorders sections in the board view, placing one before or after another. The column your team needs today sits first, where eyes land when the board opens.

Removes a section you no longer need, so old phases stop cluttering the project. Useful at the end of a cycle, when the board still shows columns nobody opens.

Retrieves the history of status updates posted on a project, one bundle per status. You see how the project evolved, update after update, without scrolling through Asana.

Reads one status update in full from its ID. The text your project lead wrote can then travel outside Asana, word for word.

Posts a status update on a project from data gathered elsewhere, so the project page stays current. Your team reads progress where it already works, and nobody compiles it by hand.

Removes a status update from a project, so the history only shows updates that are still true.

Shows every workspace your connection can reach, one bundle each. It is the first step when a scenario must cover several workspaces rather than one.

Reads the details of one workspace from its ID. Your reports and alerts can then show a name people recognize rather than a string of digits.

Returns the teams of an organization, one bundle per team, handy for mapping who owns what. You get a live list instead of a directory someone forgot to update.

Pulls the people of an organization, one bundle per user.

Adjusts who belongs to a workspace, so arrivals and departures are handled from your source of truth. Access follows the HR record, not someone's memory.

Sets up a new team in the organization without anyone opening the admin screens. The team exists the moment the decision is recorded in another tool.

Reads one team's details from its ID to reuse its name later in the scenario. Your notifications then read like a colleague wrote them, not like a log file.

You get every member of an Asana team, one bundle per person (a bundle is one item passed to the next module), ready to feed a message or a sheet.

A new colleague lands in the right Asana team without anyone opening the admin screens, so the projects of that team become visible to them.

Someone who changes roles or leaves stops seeing a team's work in Asana, and nobody has to remember to clean up access.

This hands you the people Asana knows in your account, each as its own bundle, so you can match an email from another app to an Asana user.

Once you hold a user's ID, this fills in the rest of the profile, such as the name, so a notification can greet a person rather than a number.

Starting from one person, you see every Asana team they belong to, one bundle per team, which tells you where their work lives.

The full activity trail of a task comes back: comments and the changes Asana records on it, each as a separate story bundle.

You read one specific comment or activity entry in full, which helps when a trigger only handed you its ID.

A comment appears on the task as if a teammate typed it, so updates from other tools show up where people already look.

An existing comment gets corrected in place instead of piling a second one under it, which keeps the thread readable.

A comment disappears from the task, useful to clear notes an automation left once they are no longer true.

Every file attached to a task comes back as its own bundle, which lets you copy or archive them one by one.

With an attachment's ID, you pull its details so the file can travel to another app.

A file produced elsewhere, like a PDF or a signed quote, ends up attached to the right task, where the team will look for it.

A file vanishes from its task, handy when an outdated version keeps confusing people.

All the tags in your Asana account come back, one bundle each, which is the starting point to check that a label exists before you use it.

One tag's details, starting from its ID, so a later module can display its name instead of a raw identifier.

A new label is ready in Asana, so tasks from a fresh client or campaign can be grouped from their very first day.

A tag's properties change in one place and every task wearing it follows, with no retagging.

For one task, you see which labels it carries, one bundle per tag, so a router can send it down the right path.

The labels on one task change to reflect what just happened elsewhere, so filtered views in Asana stay honest.

Make lists this module in the documentation without describing it, so treat it as a door to Asana's custom fields and read its settings in the editor before relying on it.

You get an inventory of the custom fields defined in a workspace, one bundle per field, useful to audit what exists before adding more.

One field's definition, including its options, so the next module knows which values are allowed.

A new field joins your workspace, ready to be added to projects and filled on tasks.

A field's definition changes centrally, so its new name or setup shows everywhere it is used.

A field you no longer need leaves the workspace, which unclutters every project that showed it.

A dropdown field gains a new choice, so the value coming from another tool has a place to land in Asana.

One dropdown choice is renamed or adjusted, and every task already using it follows along.

Here you learn which custom fields a given project actually uses, one bundle per field, before your scenario tries to write into them.

The set of custom fields attached to a project changes, so a fresh project gets the same fields as its siblings.

Your Asana goals come back as bundles, which makes it easy to push them into a report or a dashboard outside Asana.

The details of one goal, taken from its ID, so a message can quote its name and current state.

A new portfolio groups related projects for a client or a program, so leadership sees them side by side.

The people you pick become members of a portfolio and can follow its projects from there.

A portfolio's settings change to match reality, such as its name after a program is relaunched.

One portfolio's details, fetched by ID, to reuse its name or members further down the scenario.

Every portfolio you can reach comes back, one bundle each, which is how you find the right one by name.

The portfolio itself disappears, which tidies up the view once a client relationship has ended.

The people you name stop being members of a portfolio, so it only lists those still involved.

You get an inventory of every webhook registered on your Asana account, one bundle per webhook (a bundle is one item passed to the next module). A webhook is the line Asana uses to call Make the moment something changes.

This is your way out when none of the 91 ready-made modules covers what you need: you call any endpoint of the Asana API from the scenario, reusing the connection you already created (your Asana account linked to Make once).

Hand it a project and one of its custom fields, and the module returns the details of that single field so later steps can read its settings.