How to Integrate Replit with ClickUp

1# Quick discovery script to find your ClickUp IDs
2import requests
3import os
4
5# Temporarily use the key here to discover IDs
6# Then store everything in Replit Secrets
7API_KEY = "your-clickup-api-key-here"  # Replace, then move to Secrets
8
9headers = {
10    "Authorization": API_KEY,  # ClickUp does NOT use 'Bearer' prefix
11    "Content-Type": "application/json"
12}
13
14# Get teams (workspaces)
15teams_resp = requests.get("https://api.clickup.com/api/v2/team", headers=headers)
16teams = teams_resp.json().get("teams", [])
17for team in teams:
18    print(f"Team: {team['name']} — ID: {team['id']}")
19
20    # Get spaces in each team
21    spaces_resp = requests.get(
22        f"https://api.clickup.com/api/v2/team/{team['id']}/space",
23        headers=headers
24    )
25    for space in spaces_resp.json().get("spaces", []):
26        print(f"  Space: {space['name']} — ID: {space['id']}")
27
28        # Get lists in each space (not in folders)
29        lists_resp = requests.get(
30            f"https://api.clickup.com/api/v2/space/{space['id']}/list",
31            headers=headers
32        )
33        for lst in lists_resp.json().get("lists", []):
34            print(f"    List: {lst['name']} — ID: {lst['id']}")

1import os
2import requests
3import time
4from typing import Optional, List, Dict
5
6API_KEY = os.environ["CLICKUP_API_KEY"]
7TEAM_ID = os.environ["CLICKUP_TEAM_ID"]
8LIST_ID = os.environ["CLICKUP_LIST_ID"]
9BASE_URL = "https://api.clickup.com/api/v2"
10
11# ClickUp uses API key directly — NO 'Bearer' prefix
12HEADERS = {
13    "Authorization": API_KEY,
14    "Content-Type": "application/json"
15}
16
17# Priority constants
18URGENT, HIGH, NORMAL, LOW = 1, 2, 3, 4
19
20def create_task(
21    name: str,
22    description: str = "",
23    priority: int = NORMAL,
24    due_date: Optional[str] = None,  # Format: 'YYYY-MM-DD'
25    assignees: Optional[List[int]] = None,
26    tags: Optional[List[str]] = None,
27    custom_fields: Optional[List[Dict]] = None
28) -> dict:
29    """Create a task in the configured list."""
30    task_data = {
31        "name": name,
32        "description": description,
33        "priority": priority,
34        "assignees": assignees or [],
35        "tags": tags or []
36    }
37
38    if due_date:
39        # ClickUp requires due_date as Unix timestamp in milliseconds
40        import datetime
41        dt = datetime.datetime.strptime(due_date, "%Y-%m-%d")
42        task_data["due_date"] = int(dt.timestamp() * 1000)
43
44    if custom_fields:
45        task_data["custom_fields"] = custom_fields
46
47    response = requests.post(
48        f"{BASE_URL}/list/{LIST_ID}/task",
49        json=task_data,
50        headers=HEADERS
51    )
52    response.raise_for_status()
53    task = response.json()
54    print(f"Created task '{task['name']}' — ID: {task['id']}")
55    return task
56
57def update_task_status(task_id: str, status_name: str) -> dict:
58    """Update a task's status. Status names are case-sensitive and list-specific."""
59    response = requests.put(
60        f"{BASE_URL}/task/{task_id}",
61        json={"status": status_name},
62        headers=HEADERS
63    )
64    response.raise_for_status()
65    return response.json()
66
67def set_custom_field(task_id: str, field_id: str, value) -> None:
68    """Set a custom field value on a task."""
69    response = requests.post(
70        f"{BASE_URL}/task/{task_id}/field/{field_id}",
71        json={"value": value},
72        headers=HEADERS
73    )
74    response.raise_for_status()
75
76def list_tasks(statuses: Optional[List[str]] = None, page: int = 0) -> List[dict]:
77    """List tasks in the configured list with optional status filter."""
78    params = {"page": page}
79    if statuses:
80        # ClickUp accepts repeated query params for multiple statuses
81        for status in statuses:
82            params[f"statuses[]"] = status
83
84    response = requests.get(
85        f"{BASE_URL}/list/{LIST_ID}/task",
86        params=params,
87        headers=HEADERS
88    )
89    response.raise_for_status()
90    return response.json().get("tasks", [])
91
92def add_comment(task_id: str, comment_text: str) -> dict:
93    """Add a comment to a task."""
94    response = requests.post(
95        f"{BASE_URL}/task/{task_id}/comment",
96        json={"comment_text": comment_text, "notify_all": False},
97        headers=HEADERS
98    )
99    response.raise_for_status()
100    return response.json()
101
102if __name__ == "__main__":
103    task = create_task(
104        name="Investigate checkout error for user@example.com",
105        description="User reported a 500 error on checkout. Order ID: 12345.",
106        priority=HIGH,
107        due_date="2026-04-05",
108        tags=["bug", "checkout"]
109    )
110
111    # Add a comment with context
112    add_comment(task["id"], "Error logged at 2026-03-30 14:23 UTC. Stack trace attached.")
113
114    # Get open tasks
115    open_tasks = list_tasks(statuses=["Open", "In Progress"])
116    print(f"Open tasks: {len(open_tasks)}")
117    for t in open_tasks:
118        print(f"  [{t.get('priority', {}).get('priority', 'none')}] {t['name']}")

1const express = require('express');
2const crypto = require('crypto');
3
4const app = express();
5
6// Use raw body for webhook signature verification
7app.use('/clickup/webhook', express.raw({ type: 'application/json' }));
8app.use(express.json());
9
10const API_KEY = process.env.CLICKUP_API_KEY;
11const TEAM_ID = process.env.CLICKUP_TEAM_ID;
12const LIST_ID = process.env.CLICKUP_LIST_ID;
13const WEBHOOK_SECRET = process.env.CLICKUP_WEBHOOK_SECRET || '';
14const BASE_URL = 'https://api.clickup.com/api/v2';
15
16// ClickUp does NOT use 'Bearer' prefix — raw API key in Authorization header
17const headers = {
18  'Authorization': API_KEY,
19  'Content-Type': 'application/json'
20};
21
22async function clickupRequest(path, method = 'GET', body = null) {
23  const response = await fetch(`${BASE_URL}${path}`, {
24    method,
25    headers,
26    body: body ? JSON.stringify(body) : undefined
27  });
28  if (!response.ok) {
29    const error = await response.text();
30    throw new Error(`ClickUp API error ${response.status}: ${error}`);
31  }
32  return response.json();
33}
34
35// Create a task
36app.post('/tasks', async (req, res) => {
37  const { name, description, priority, dueDate, tags } = req.body;
38  if (!name) return res.status(400).json({ error: 'name is required' });
39
40  const taskData = {
41    name,
42    description: description || '',
43    priority: priority || 3,  // 1=urgent, 2=high, 3=normal, 4=low
44    tags: tags || []
45  };
46
47  if (dueDate) {
48    taskData.due_date = new Date(dueDate).getTime(); // Milliseconds timestamp
49  }
50
51  try {
52    const task = await clickupRequest(`/list/${LIST_ID}/task`, 'POST', taskData);
53    res.json({ success: true, id: task.id, url: task.url });
54  } catch (err) {
55    res.status(500).json({ error: err.message });
56  }
57});
58
59// Update task status
60app.patch('/tasks/:id/status', async (req, res) => {
61  const { status } = req.body;
62  try {
63    const task = await clickupRequest(`/task/${req.params.id}`, 'PUT', { status });
64    res.json({ success: true, status: task.status?.status });
65  } catch (err) {
66    res.status(500).json({ error: err.message });
67  }
68});
69
70// Register a webhook (call once after deploying)
71app.post('/register-webhook', async (req, res) => {
72  const callbackUrl = `https://${req.headers.host}/clickup/webhook`;
73  try {
74    const webhook = await clickupRequest(`/team/${TEAM_ID}/webhook`, 'POST', {
75      endpoint: callbackUrl,
76      events: ['taskCreated', 'taskStatusUpdated', 'taskUpdated'],
77      list_id: LIST_ID  // Optional: filter by list
78    });
79    res.json({
80      success: true,
81      webhookId: webhook.id,
82      secret: webhook.secret,
83      message: 'Store the secret as CLICKUP_WEBHOOK_SECRET in Replit Secrets'
84    });
85  } catch (err) {
86    res.status(500).json({ error: err.message });
87  }
88});
89
90// Receive ClickUp webhook events
91app.post('/clickup/webhook', (req, res) => {
92  // Verify HMAC signature
93  if (WEBHOOK_SECRET) {
94    const signature = req.headers['x-signature'];
95    const computed = crypto
96      .createHmac('sha256', WEBHOOK_SECRET)
97      .update(req.body)  // Raw body buffer
98      .digest('base64');
99    if (signature !== computed) {
100      console.warn('Invalid ClickUp webhook signature');
101      return res.status(403).json({ error: 'Invalid signature' });
102    }
103  }
104
105  const payload = JSON.parse(req.body);
106  const { event, task_id, history_items } = payload;
107
108  console.log(`ClickUp webhook: ${event} for task ${task_id}`);
109
110  if (event === 'taskStatusUpdated') {
111    const newStatus = history_items?.[0]?.after?.status;
112    console.log(`Task ${task_id} status changed to: ${newStatus}`);
113    // Update your database, trigger notifications, etc.
114  }
115
116  res.json({ received: true });
117});
118
119app.listen(3000, '0.0.0.0', () => {
120  console.log('ClickUp integration server running on port 3000');
121});