Skip to main content
Glama

create_task

Create a new task in a ClickUp list by providing required fields like list ID and name, plus optional details such as description, assignees, status, dates, and priority.

Instructions

Create a new task in a ClickUp list with specified properties like name, description, assignees, status, and dates.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
list_idYesThe ID of the list to create the task in
nameYesThe name of the task
descriptionNoThe description of the task
assigneesNoThe IDs of the users to assign to the task
tagsNoThe tags to add to the task
statusNoThe status of the task
priorityNoThe priority of the task (1-4)
due_dateNoThe due date of the task (Unix timestamp)
due_date_timeNoWhether the due date includes a time
time_estimateNoThe time estimate for the task (in milliseconds)
start_dateNoThe start date of the task (Unix timestamp)
start_date_timeNoWhether the start date includes a time
notify_allNoWhether to notify all assignees
parentNoThe ID of the parent task

Implementation Reference

  • The MCP tool handler for 'create_task'. Registers the tool with server.tool(), defines its Zod schema for inputs (list_id, name, description, assignees, tags, status, priority, due_date, due_date_time, time_estimate, start_date, start_date_time, notify_all, parent), and calls tasksClient.createTask().
    server.tool(
      'create_task',
      'Create a new task in a ClickUp list with specified properties like name, description, assignees, status, and dates.',
      {
        list_id: z.string().describe('The ID of the list to create the task in'),
        name: z.string().describe('The name of the task'),
        description: z.string().optional().describe('The description of the task'),
        assignees: z.array(z.number()).optional().describe('The IDs of the users to assign to the task'),
        tags: z.array(z.string()).optional().describe('The tags to add to the task'),
        status: z.string().optional().describe('The status of the task'),
        priority: z.number().optional().describe('The priority of the task (1-4)'),
        due_date: z.number().optional().describe('The due date of the task (Unix timestamp)'),
        due_date_time: z.boolean().optional().describe('Whether the due date includes a time'),
        time_estimate: z.number().optional().describe('The time estimate for the task (in milliseconds)'),
        start_date: z.number().optional().describe('The start date of the task (Unix timestamp)'),
        start_date_time: z.boolean().optional().describe('Whether the start date includes a time'),
        notify_all: z.boolean().optional().describe('Whether to notify all assignees'),
        parent: z.string().optional().describe('The ID of the parent task')
      },
      async ({ list_id, ...taskParams }) => {
        try {
          const result = await tasksClient.createTask(list_id, taskParams as CreateTaskParams);
          return {
            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
          };
        } catch (error: any) {
          console.error('Error creating task:', error);
          return {
            content: [{ type: 'text', text: `Error creating task: ${error.message}` }],
            isError: true
          };
        }
      }
  • The CreateTaskParams interface defining all input parameters for creating a task, including name (required), description, assignees, tags, status, priority, due_date, due_date_time, time_estimate, start_date, start_date_time, notify_all, parent, links_to, check_required_custom_fields, and custom_fields.
    export interface CreateTaskParams {
      name: string;
      description?: string;
      assignees?: number[];
      tags?: string[];
      status?: string;
      priority?: number;
      due_date?: number;
      due_date_time?: boolean;
      time_estimate?: number;
      start_date?: number;
      start_date_time?: boolean;
      notify_all?: boolean;
      parent?: string;
      links_to?: string;
      check_required_custom_fields?: boolean;
      custom_fields?: Array<{
        id: string;
        value: any;
      }>;
    }
  • src/index.ts:40-47 (registration)
    The 'create_task' tool is registered indirectly via setupTaskTools() which is called in the ClickUpServer.setupTools() method.
    private setupTools() {
      // Set up all tools
      setupTaskTools(this.server);
      setupDocTools(this.server);
      setupSpaceTools(this.server);
      setupChecklistTools(this.server);
      setupCommentTools(this.server);
    }
  • The createTask() method on TasksClient that performs the actual API call: this.client.post('/list/${listId}/task', params).
    async createTask(listId: string, params: CreateTaskParams): Promise<Task> {
      return this.client.post(`/list/${listId}/task`, params);
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It implies mutation but does not disclose synchronous/asynchronous behavior, required permissions, error handling (e.g., invalid list_id), or whether notifications are sent by default (though there is a notify_all param). The description adds minimal behavioral context beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single 23-word sentence, front-loaded with the action and key properties. It is concise but could benefit from a second sentence providing usage or behavioral guidance without becoming overly long.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (14 parameters, no output schema), the description is too sparse. It does not mention return values, error scenarios, or dependencies (e.g., list must exist). Annotations are absent, so the description should compensate but fails to do so.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description lists some parameters (name, description, assignees, status, dates) but adds no additional meaning beyond what the schema provides, such as constraints between parameters or valid values.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (create), the resource (a task in a ClickUp list), and enumerates possible properties (name, description, assignees, status, dates). It distinguishes from siblings like 'add_task_to_list' (which likely moves an existing task) and 'update_task' (modification).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. Sibling tools like 'add_task_to_list' exist, but the description does not differentiate usage scenarios. It does not mention prerequisites or when not to use this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/nsxdavid/clickup-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server