ClickUp

ClickUp is a community skill for project management integration, covering task operations, list management, workspace navigation, user access, and webhook configuration for automated project workflows.

What Is This?

Overview

ClickUp provides programmatic access to the ClickUp project management platform for automating task management and team collaboration workflows. It covers task operations that create, update, assign, and track tasks with custom fields, due dates, priorities, and status updates, list management that organizes tasks into lists and folders with customizable views and filtering options, workspace navigation that traverses the hierarchy from workspaces to spaces, folders, and lists for structured project organization, user access that retrieves team member information and manages task assignments and permissions, and webhook configuration that triggers automated actions when tasks change status or assignments update. The skill enables developers to integrate ClickUp with external tools and automate project management workflows without manual data entry through the ClickUp interface.

Who Should Use This

This skill serves development teams automating task creation from code commits, project managers building custom reporting dashboards, and operations teams integrating ClickUp with business systems.

Why Use It?

Problems It Solves

Manual task creation for recurring workflows and integration events is repetitive and slows team velocity. Extracting project data for reporting requires navigating the ClickUp UI and manual export processes regularly. Keeping tasks synchronized across multiple tools like GitHub, Slack, and ClickUp requires constant manual updates. Tracking task progress and generating status reports manually from project data is time-consuming and error-prone.

Core Highlights

Task manager creates and updates tasks with custom fields and assignments. List organizer structures projects into hierarchical folders and lists. Workspace navigator traverses spaces and organizational structure programmatically. Webhook configurator triggers automation when tasks change state.

How to Use It?

Basic Usage

import requests
import os

api_key = os.environ['CLICKUP_API_KEY']
headers = {
    'Authorization': api_key
}

list_id = '123456'
response = requests.get(
    f'https://api.clickup.com/api/v2'
    f'/list/{list_id}/task',
    headers=headers
)
tasks = response.json()['tasks']

new_task = requests.post(
    f'https://api.clickup.com/api/v2'
    f'/list/{list_id}/task',
    headers=headers,
    json={
        'name': 'New Feature Implementation',
        'description': 'Build the API endpoint',
        'status': 'to do',
        'priority': 2,
        'due_date': 1711929600000
    }
)

Real-World Examples

task_id = 'abc123'
requests.put(
    f'https://api.clickup.com/api/v2'
    f'/task/{task_id}',
    headers=headers,
    json={
        'status': 'in progress',
        'custom_fields': [
            {
                'id': 'field_123',
                'value': 'High Impact'
            }
        ]
    }
)

workspaces = requests.get(
    'https://api.clickup.com/api/v2'
    '/team',
    headers=headers
).json()['teams']

for workspace in workspaces:
    spaces = requests.get(
        f'https://api.clickup.com/api/v2'
        f'/team/{workspace["id"]}/space',
        headers=headers
    ).json()['spaces']
    
    for space in spaces:
        print(f'{workspace["name"]} > '
              f'{space["name"]}')

webhook = requests.post(
    f'https://api.clickup.com/api/v2'
    f'/list/{list_id}/webhook',
    headers=headers,
    json={
        'endpoint': 'https://myapp.com/webhook',
        'events': ['taskCreated', 'taskUpdated']
    }
)

Advanced Tips

Use custom field IDs instead of names when updating tasks to ensure consistency across different ClickUp workspaces and configurations. Implement webhook handlers to receive real-time task updates instead of polling the API for changes reducing latency and API usage. Cache workspace and space hierarchies to avoid repeated traversal calls when navigating project structures frequently in your application.

When to Use It?

Use Cases

Automatically create ClickUp tasks when GitHub issues are opened or pull requests need review linking code and project management. Build custom dashboards that aggregate task data across multiple workspaces and projects with advanced filtering and analytics. Sync task status between ClickUp and other project management tools maintaining consistency across platforms.

Related Topics

Project management, task tracking, ClickUp API, team collaboration, workflow automation, and integration platforms.

Important Notes

Requirements

ClickUp account with API access enabled and personal API token or OAuth credentials generated for authentication. Understanding of ClickUp's workspace hierarchy including teams, spaces, folders, and lists for effective navigation. Webhook endpoint URL if implementing real-time task update notifications with proper authentication and validation.

Usage Recommendations

Do: use pagination parameters when retrieving task lists since large projects may have thousands of tasks exceeding single response limits. Implement proper error handling for API rate limits and network failures that are common in integration scenarios. Test custom field updates thoroughly since field IDs and types vary across workspaces requiring validation.

Don't: hard-code workspace, space, or list IDs since they vary across ClickUp instances and organizational structures requiring configuration. Make excessive API calls without caching frequently accessed data like workspace hierarchies and user information. Ignore webhook signature verification since unverified webhooks can be spoofed by malicious actors.

Limitations

ClickUp API rate limits vary by plan tier and may restrict high-volume integrations requiring careful request throttling and batching. Some advanced ClickUp features like custom views and dashboards have limited API support for programmatic access and configuration. Custom field types and configurations vary significantly across workspaces making generic integration logic challenging without workspace-specific handling. Webhook delivery is not guaranteed and may experience delays during high system load requiring retry mechanisms for critical operations.