Skip to main content

Asana Advanced Features MCP Server

Create a powerful Model Context Protocol (MCP) server for Asana's advanced features in minutes with our AI Gateway. This guide walks you through setting up comprehensive project management capabilities including automation, portfolios, and templates with instant OAuth authentication.

About Asana Advanced APIs​

Asana's advanced APIs provide access to powerful features beyond basic task management, including portfolio management, custom templates, automation rules, and advanced search capabilities. These APIs enable enterprise-grade project management and workflow automation.

Key Capabilities​

  • Portfolio Management: Multi-project views, status rollups, dashboards
  • Automation Rules: Trigger-based workflows, custom actions, integrations
  • Templates: Project templates, task templates, process standardization
  • Advanced Search: Cross-project queries, saved searches, custom fields
  • Forms: Intake management, request routing, data collection
  • Goals: OKR tracking, progress monitoring, alignment
  • Workload: Resource management, capacity planning, allocation
  • Timeline: Gantt charts, dependencies, critical path

API Features​

  • RESTful API: Comprehensive REST endpoints
  • OAuth 2.0: Secure authentication
  • Webhooks: Real-time event notifications
  • Batch API: Bulk operations support
  • Custom Fields: Extensible data model
  • Rich Text: Formatted descriptions
  • File Attachments: Document management
  • Rate Limiting: Fair usage policies

What You Can Do with Asana Advanced MCP Server​

The MCP server transforms Asana's advanced APIs into a natural language interface, enabling AI agents to:

Portfolio Management​

  • Portfolio Operations

    • "Create portfolio for Q1 initiatives"
    • "Add projects to marketing portfolio"
    • "Update portfolio status fields"
    • "Generate portfolio dashboard"

  • Portfolio Analytics

    • "Show portfolio health metrics"
    • "Track cross-project progress"
    • "Identify at-risk projects"
    • "Calculate portfolio ROI"

  • Resource Views

    • "Show team workload across portfolios"
    • "Balance resource allocation"
    • "Identify overallocated members"
    • "Forecast capacity needs"

Automation & Rules​

  • Rule Creation

    • "Create rule for task assignment"
    • "Set up status change triggers"
    • "Automate due date updates"
    • "Configure approval workflows"

  • Trigger Types

    • "On task creation"
    • "When custom field changes"
    • "At specific time"
    • "On form submission"

  • Actions

    • "Auto-assign to team member"
    • "Move to different project"
    • "Update custom fields"
    • "Create subtasks"

Templates​

  • Project Templates

    • "Create project template"
    • "Save as template"
    • "Customize template tasks"
    • "Share across organization"

  • Task Templates

    • "Create task template"
    • "Include subtask structure"
    • "Set default assignees"
    • "Configure dependencies"

  • Process Templates

    • "Build workflow template"
    • "Define standard processes"
    • "Create onboarding template"
    • "Design review cycles"

  • Complex Queries

    • "Find tasks due this week across all projects"
    • "Search incomplete tasks assigned to me"
    • "Locate tasks with specific tags"
    • "Find overdue high-priority items"

  • Saved Searches

    • "Save search as report"
    • "Create team dashboard"
    • "Schedule search alerts"
    • "Export search results"

  • Cross-Workspace

    • "Search across teams"
    • "Find cross-functional dependencies"
    • "Track organization-wide initiatives"
    • "Monitor global metrics"

Forms & Requests​

  • Form Builder

    • "Create intake form"
    • "Design request form"
    • "Add conditional logic"
    • "Set up routing rules"

  • Form Management

    • "Process form submissions"
    • "Auto-create tasks from forms"
    • "Route to appropriate team"
    • "Track request status"

  • Custom Fields

    • "Add dropdown field"
    • "Create number field"
    • "Set up date fields"
    • "Configure field permissions"

Goals & OKRs​

  • Goal Management

    • "Create company goals"
    • "Set quarterly OKRs"
    • "Link projects to goals"
    • "Track goal progress"

  • Progress Tracking

    • "Update goal metrics"
    • "Calculate completion percentage"
    • "Show goal timeline"
    • "Identify blockers"

  • Alignment

    • "Connect team goals to company goals"
    • "Show goal hierarchy"
    • "Track contributing work"
    • "Measure impact"

Workload Management​

  • Capacity Planning

    • "Show team capacity"
    • "Identify availability"
    • "Balance workload"
    • "Plan sprint capacity"

  • Resource Allocation

    • "Assign based on capacity"
    • "Redistribute overload"
    • "Schedule time off"
    • "Forecast needs"

  • Effort Tracking

    • "Set task effort"
    • "Track actual vs planned"
    • "Monitor productivity"
    • "Optimize allocation"

Prerequisites​

  • Access to Cequence AI Gateway
  • Asana Business or Enterprise account
  • Admin or appropriate permissions
  • OAuth app configuration

Step 1: Configure Asana API Access​

1.1 Create OAuth Application​

  1. Go to Asana Developer Console
  2. Click Create New App
  3. Configure app settings:
    • App Name: "AI Gateway Integration"
    • Authentication: OAuth
    • Redirect URLs: From AI Gateway

1.2 Configure OAuth Settings​

  1. Note Client ID and Client Secret
  2. Set required scopes:
    • Default (read/write all data)
    • Optional: Limit to specific permissions
  3. Configure redirect URI

1.3 Get Workspace Information​

  1. Navigate to workspace settings
  2. Note Workspace GID (Global ID)
  3. Identify team GIDs if needed

1.4 Enable Advanced Features​

Ensure account has access to:

  • Portfolios
  • Custom Fields
  • Forms
  • Rules (Business+)
  • Goals (Business+)
  • Workload (Business+)

Step 2-4: Standard Setup​

Follow standard steps to access AI Gateway, find Asana API, and create MCP server.

Step 5: Configure API Endpoints​

  1. Base URL: https://app.asana.com/api/1.0
  2. OAuth Authorization: https://app.asana.com/-/oauth_authorize
  3. OAuth Token: https://app.asana.com/-/oauth_token
  4. Click Next

Step 6: MCP Server Configuration​

  1. Name: "Asana Advanced"
  2. Description: "Advanced project management features"
  3. Features: Enable all advanced modules
  4. Click Next

Step 7: Configure Authentication​

  1. Authentication Type: OAuth 2.0
  2. Client ID: From developer console
  3. Client Secret: From developer console
  4. Default Workspace: Your workspace GID
  5. Complete OAuth flow

Available Asana Advanced API Operations​

Portfolio APIs​

  • Portfolio Management

    • Create portfolio
    • Update portfolio
    • Add/remove items
    • Get portfolio items

  • Portfolio Fields

    • Custom fields
    • Status updates
    • Color coding
    • Owner management

Automation APIs​

  • Rules

    • Create rule
    • Update rule
    • List rules
    • Delete rule

  • Triggers & Actions

    • Configure triggers
    • Set up actions
    • Manage conditions

Template APIs​

  • Project Templates

    • Create from project
    • Instantiate template
    • Update template

  • Template Management

    • List templates
    • Share templates
    • Delete templates

Search APIs​

  • Advanced Search
    • Search tasks
    • Search projects
    • Search conversations
    • Search attachments

Form APIs​

  • Forms
    • Create form
    • Update form
    • Get submissions
    • Process responses

Goal APIs​

  • Goals
    • Create goal
    • Update progress
    • Link work
    • Track metrics

Step 8-10: Complete Setup​

Configure security settings, choose deployment options, and deploy your server.

Using Your Asana Advanced MCP Server​

With Claude Desktop​

{
  "servers": {
    "asana-advanced": {
      "url": "your-mcp-server-url",
      "auth": {
        "type": "oauth2",
        "client_id": "your-client-id",
        "workspace_gid": "your-workspace-gid"
      }
    }
  }
}

Natural Language Commands​

  • "Create a portfolio for all Q1 product initiatives"
  • "Set up automation to assign design tasks to Sarah"
  • "Find all overdue tasks across marketing projects"
  • "Create project template for product launches"
  • "Show team workload for next two weeks"

API Integration Example​

// Initialize MCP client
const mcpClient = new MCPClient({
  serverUrl: 'your-mcp-server-url',
  auth: {
    type: 'oauth2',
    accessToken: 'your-access-token'
  }
});

// Create a portfolio
const portfolio = await mcpClient.asana.createPortfolio({
  name: 'Q1 2025 Product Initiatives',
  description: 'Track all product development for Q1',
  color: 'dark-blue',
  workspace: workspaceGid,
  owner: 'me',
  members: ['sarah@company.com', 'john@company.com'],
  custom_fields: [
    {
      gid: 'field_status',
      value: 'on_track'
    },
    {
      gid: 'field_priority',
      value: 'high'
    }
  ]
});

// Add projects to portfolio
const portfolioItems = await mcpClient.asana.addPortfolioItems({
  portfolio: portfolio.gid,
  items: [
    { project: 'project_mobile_app' },
    { project: 'project_api_v2' },
    { project: 'project_analytics' }
  ]
});

// Create automation rule
const automationRule = await mcpClient.asana.createRule({
  name: 'Auto-assign design tasks',
  project: projectGid,
  trigger: {
    type: 'task_added',
    conditions: {
      custom_field: {
        gid: 'field_task_type',
        value: 'design'
      }
    }
  },
  actions: [
    {
      type: 'assign_task',
      assignee: 'sarah@company.com'
    },
    {
      type: 'add_tag',
      tag: 'design-review'
    },
    {
      type: 'set_custom_field',
      field_gid: 'field_priority',
      value: 'high'
    }
  ]
});

// Create project template
const template = await mcpClient.asana.createProjectTemplate({
  name: 'Product Launch Template',
  description: 'Standard process for product launches',
  source_project: existingProjectGid,
  include: {
    tasks: true,
    task_subtasks: true,
    task_attachments: false,
    project_custom_fields: true,
    project_forms: true,
    project_rules: true
  },
  template_options: {
    dates: {
      should_skip_weekends: true,
      start_on: 'project_start'
    }
  }
});

// Advanced search across workspace
const searchResults = await mcpClient.asana.searchTasks({
  workspace: workspaceGid,
  criteria: {
    assignee: 'me',
    due_date: {
      operator: 'between',
      start: '2025-02-01',
      end: '2025-02-28'
    },
    custom_fields: [
      {
        gid: 'field_priority',
        operator: 'equals',
        value: 'high'
      }
    ],
    projects: {
      operator: 'any'
    },
    completed: false
  },
  sort: 'due_date',
  limit: 100
});

// Create form for requests
const form = await mcpClient.asana.createForm({
  name: 'Marketing Request Form',
  project: projectGid,
  description: 'Submit marketing requests',
  questions: [
    {
      type: 'text',
      title: 'Request Title',
      required: true
    },
    {
      type: 'dropdown',
      title: 'Request Type',
      options: ['Campaign', 'Content', 'Design', 'Other'],
      required: true
    },
    {
      type: 'date',
      title: 'Needed By',
      required: true
    },
    {
      type: 'text_area',
      title: 'Description',
      description: 'Provide details about your request'
    },
    {
      type: 'attachment',
      title: 'Reference Materials',
      required: false
    }
  ],
  completion_message: 'Thank you! We\'ll review your request within 24 hours.',
  form_metadata: {
    routing: {
      rules: [
        {
          condition: {
            question: 'Request Type',
            value: 'Design'
          },
          action: {
            assign_to: 'design-team'
          }
        }
      ]
    }
  }
});

// Create company OKRs
const companyGoal = await mcpClient.asana.createGoal({
  name: 'Increase Customer Satisfaction',
  description: 'Improve NPS score to 70+',
  workspace: workspaceGid,
  owner: 'ceo@company.com',
  time_period: 'Q1-2025',
  metric: {
    type: 'number',
    initial_value: 62,
    target_value: 70,
    current_value: 62,
    unit: 'NPS Score'
  },
  status: 'green',
  liked: true
});

// Link projects to goal
await mcpClient.asana.addSupportingWork({
  goal: companyGoal.gid,
  supporting_work: [
    { project: 'project_cx_improvements' },
    { project: 'project_support_automation' },
    { task: 'task_quarterly_survey' }
  ]
});

// Workload management
const teamWorkload = await mcpClient.asana.getTeamWorkload({
  team: teamGid,
  start_date: '2025-02-01',
  end_date: '2025-02-14',
  assignees: ['john@company.com', 'sarah@company.com', 'mike@company.com']
});

// Balance workload
for (const member of teamWorkload.members) {
  if (member.utilization > 120) {
    // Find tasks to reassign
    const tasks = await mcpClient.asana.getAssigneeTasks({
      assignee: member.gid,
      opt_fields: ['effort', 'due_on', 'projects']
    });
    
    // Reassign lower priority tasks
    const tasksToReassign = tasks.filter(t => 
      t.custom_fields.priority !== 'high'
    ).slice(0, 3);
    
    for (const task of tasksToReassign) {
      await mcpClient.asana.reassignTask({
        task: task.gid,
        assignee: findAvailableTeamMember(teamWorkload)
      });
    }
  }
}

// Create saved search report
const savedSearch = await mcpClient.asana.createSavedSearch({
  name: 'Weekly Status Report',
  description: 'Tasks due this week across all projects',
  workspace: workspaceGid,
  query: {
    task_type: 'task',
    due_date: 'this_week',
    assignee: 'any',
    completed: false,
    projects: 'any'
  },
  columns: [
    'name',
    'assignee',
    'due_date',
    'projects',
    'custom_field_priority',
    'custom_field_status'
  ],
  sort: [
    { field: 'due_date', direction: 'asc' },
    { field: 'priority', direction: 'desc' }
  ]
});

// Bulk operations with templates
const newProjects = await mcpClient.asana.bulkCreateFromTemplate({
  template: template.gid,
  instances: [
    {
      name: 'Product A Launch',
      start_date: '2025-03-01',
      team: 'team_product_a'
    },
    {
      name: 'Product B Launch',
      start_date: '2025-04-01',
      team: 'team_product_b'
    }
  ]
});

// Monitor portfolio health
const portfolioHealth = await mcpClient.asana.getPortfolioMetrics({
  portfolio: portfolio.gid,
  metrics: ['status_distribution', 'overdue_tasks', 'completion_rate', 'risk_score']
});

console.log(`Portfolio Health Score: ${portfolioHealth.overall_score}`);
console.log(`At Risk Projects: ${portfolioHealth.at_risk_count}`);
console.log(`On Track: ${portfolioHealth.on_track_percentage}%`);

Common Use Cases​

Portfolio Management​

  • Executive dashboards
  • Program tracking
  • Resource planning
  • Risk management

Process Automation​

  • Request intake
  • Approval workflows
  • Status updates
  • Task routing

Team Coordination​

  • Workload balancing
  • Capacity planning
  • Cross-functional projects
  • Dependencies tracking

Reporting & Analytics​

  • Custom dashboards
  • Progress reports
  • Team metrics
  • Goal tracking

Best Practices​

  1. Template Design:

    • Standardize processes
    • Include clear instructions
    • Set realistic timelines
    • Test before deploying

  2. Automation Rules:

    • Start simple
    • Test thoroughly
    • Document logic
    • Monitor performance

  3. Portfolio Structure:

    • Group logically
    • Use consistent fields
    • Regular reviews
    • Clear ownership

Troubleshooting​

Common Issues​

  1. Permission Errors

    • Check workspace access
    • Verify feature availability
    • Review team permissions
    • Confirm OAuth scopes

  2. Automation Failures

    • Check trigger conditions
    • Verify action permissions
    • Review error logs
    • Test with simple rules

  3. Search Performance

    • Limit date ranges
    • Use specific filters
    • Paginate results
    • Index custom fields

Getting Help​