How to Integrate Replit with Asana

1# Quick helper to find your workspace and project GIDs
2import requests
3import os
4
5# Temporarily use the token directly to discover GIDs
6# Then store everything in Replit Secrets
7TOKEN = "your-personal-access-token-here"  # Replace, then move to Secrets
8
9headers = {
10    "Authorization": f"Bearer {TOKEN}",
11    "Accept": "application/json"
12}
13
14# Get workspaces
15workspaces_resp = requests.get("https://app.asana.com/api/1.0/workspaces", headers=headers)
16for ws in workspaces_resp.json().get("data", []):
17    print(f"Workspace: {ws['name']} — GID: {ws['gid']}")
18
19# Get projects in a workspace (replace WORKSPACE_GID)
20WORKSPACE_GID = "your-workspace-gid"
21projects_resp = requests.get(
22    f"https://app.asana.com/api/1.0/workspaces/{WORKSPACE_GID}/projects",
23    headers=headers
24)
25for project in projects_resp.json().get("data", []):
26    print(f"Project: {project['name']} — GID: {project['gid']}")

1import os
2import requests
3from typing import Optional, List
4
5ASANA_TOKEN = os.environ["ASANA_ACCESS_TOKEN"]
6WORKSPACE_GID = os.environ["ASANA_WORKSPACE_GID"]
7PROJECT_GID = os.environ["ASANA_PROJECT_GID"]
8BASE_URL = "https://app.asana.com/api/1.0"
9
10HEADERS = {
11    "Authorization": f"Bearer {ASANA_TOKEN}",
12    "Content-Type": "application/json",
13    "Accept": "application/json"
14}
15
16def create_task(
17    name: str,
18    notes: str = "",
19    assignee_gid: Optional[str] = None,
20    due_on: Optional[str] = None,
21    section_gid: Optional[str] = None
22) -> dict:
23    """Create a task in the configured project."""
24    task_data = {
25        "data": {
26            "name": name,
27            "notes": notes,
28            "workspace": WORKSPACE_GID,
29            "projects": [PROJECT_GID]
30        }
31    }
32    if assignee_gid:
33        task_data["data"]["assignee"] = assignee_gid
34    if due_on:
35        task_data["data"]["due_on"] = due_on  # Format: YYYY-MM-DD
36
37    response = requests.post(f"{BASE_URL}/tasks", json=task_data, headers=HEADERS)
38    response.raise_for_status()
39    task = response.json()["data"]
40
41    # Optionally move task to a specific section
42    if section_gid:
43        move_task_to_section(task["gid"], section_gid)
44
45    print(f"Created task '{name}' with GID: {task['gid']}")
46    return task
47
48def complete_task(task_gid: str) -> dict:
49    """Mark a task as complete."""
50    response = requests.put(
51        f"{BASE_URL}/tasks/{task_gid}",
52        json={"data": {"completed": True}},
53        headers=HEADERS
54    )
55    response.raise_for_status()
56    return response.json()["data"]
57
58def update_task(task_gid: str, updates: dict) -> dict:
59    """Update any task fields."""
60    response = requests.put(
61        f"{BASE_URL}/tasks/{task_gid}",
62        json={"data": updates},
63        headers=HEADERS
64    )
65    response.raise_for_status()
66    return response.json()["data"]
67
68def add_comment(task_gid: str, text: str) -> dict:
69    """Add a comment (story) to a task."""
70    response = requests.post(
71        f"{BASE_URL}/tasks/{task_gid}/stories",
72        json={"data": {"text": text}},
73        headers=HEADERS
74    )
75    response.raise_for_status()
76    return response.json()["data"]
77
78def list_incomplete_tasks() -> List[dict]:
79    """List all incomplete tasks in the configured project."""
80    tasks = []
81    params = {
82        "project": PROJECT_GID,
83        "completed_since": "now",  # Only incomplete tasks
84        "opt_fields": "name,assignee.name,due_on,notes,completed"
85    }
86    response = requests.get(f"{BASE_URL}/tasks", params=params, headers=HEADERS)
87    response.raise_for_status()
88    return response.json()["data"]
89
90def move_task_to_section(task_gid: str, section_gid: str) -> None:
91    """Move a task into a specific section."""
92    requests.post(
93        f"{BASE_URL}/sections/{section_gid}/addTask",
94        json={"data": {"task": task_gid}},
95        headers=HEADERS
96    ).raise_for_status()
97
98if __name__ == "__main__":
99    task = create_task(
100        name="Review pull request #42",
101        notes="Check the API integration changes in PR #42 before merging.",
102        due_on="2026-04-07"
103    )
104    print(f"Task URL: https://app.asana.com/0/{PROJECT_GID}/{task['gid']}")
105
106    tasks = list_incomplete_tasks()
107    print(f"Incomplete tasks: {len(tasks)}")
108    for t in tasks:
109        print(f"  - {t['name']} (due: {t.get('due_on', 'no date')})")

1const express = require('express');
2const asana = require('asana');
3const crypto = require('crypto');
4
5const app = express();
6app.use(express.json());
7
8// Initialize Asana client from Replit Secrets
9const client = asana.ApiClient.instance;
10const token = client.authentications['token'];
11token.accessToken = process.env.ASANA_ACCESS_TOKEN;
12
13const tasksApi = new asana.TasksApi();
14const storiesApi = new asana.StoriesApi();
15const webhooksApi = new asana.WebhooksApi();
16
17const PROJECT_GID = process.env.ASANA_PROJECT_GID;
18const WORKSPACE_GID = process.env.ASANA_WORKSPACE_GID;
19
20// Store webhook secret after handshake
21let webhookSecret = '';
22
23// Create a task
24app.post('/tasks', async (req, res) => {
25  const { name, notes, dueOn, assigneeGid } = req.body;
26  if (!name) return res.status(400).json({ error: 'name is required' });
27
28  try {
29    const taskData = {
30      data: {
31        name,
32        notes: notes || '',
33        projects: [PROJECT_GID],
34        workspace: WORKSPACE_GID,
35        due_on: dueOn || undefined,
36        assignee: assigneeGid || undefined
37      }
38    };
39    const response = await tasksApi.createTask(taskData);
40    const task = response.data;
41    res.json({ success: true, gid: task.gid, name: task.name });
42  } catch (err) {
43    console.error('Create task error:', err.response?.body);
44    res.status(500).json({ error: err.message });
45  }
46});
47
48// Complete a task
49app.patch('/tasks/:gid/complete', async (req, res) => {
50  try {
51    const response = await tasksApi.updateTask({ data: { completed: true } }, req.params.gid);
52    res.json({ success: true, completed: response.data.completed });
53  } catch (err) {
54    res.status(500).json({ error: err.message });
55  }
56});
57
58// Asana webhook handler — handles both handshake and events
59app.post('/asana/webhook', (req, res) => {
60  // Step 1: One-time handshake when webhook is first registered
61  const hookSecret = req.headers['x-hook-secret'];
62  if (hookSecret) {
63    webhookSecret = hookSecret;
64    console.log('Asana webhook handshake received — secret stored');
65    res.set('X-Hook-Secret', hookSecret);
66    return res.status(200).send();
67  }
68
69  // Step 2: Verify signature on subsequent events
70  const signature = req.headers['x-hook-signature'];
71  if (webhookSecret && signature) {
72    const hmac = crypto.createHmac('sha256', webhookSecret);
73    hmac.update(JSON.stringify(req.body));
74    const expectedSig = hmac.digest('hex');
75    if (signature !== expectedSig) {
76      console.warn('Invalid webhook signature');
77      return res.status(403).json({ error: 'Invalid signature' });
78    }
79  }
80
81  // Process events
82  const events = req.body.events || [];
83  events.forEach(event => {
84    console.log(`Asana event: ${event.action} on ${event.resource?.resource_type} ${event.resource?.gid}`);
85    if (event.action === 'changed' && event.resource?.resource_type === 'task') {
86      // Handle task change — update your database, send notifications, etc.
87    }
88  });
89
90  res.json({ received: true });
91});
92
93// Register a webhook (call once after deploying)
94app.post('/register-webhook', async (req, res) => {
95  const callbackUrl = `https://${req.headers.host}/asana/webhook`;
96  try {
97    const webhook = await webhooksApi.createWebhook({
98      data: {
99        resource: PROJECT_GID,
100        target: callbackUrl
101      }
102    });
103    res.json({ success: true, webhookGid: webhook.data.gid });
104  } catch (err) {
105    res.status(500).json({ error: err.message });
106  }
107});
108
109app.listen(3000, '0.0.0.0', () => {
110  console.log('Asana integration server running on port 3000');
111});