> ## Documentation Index
> Fetch the complete documentation index at: https://developers.wrike.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Tasks (Account)

Search among all tasks in current account.

<b>Scopes:</b> Default, wsReadOnly, wsReadWrite

# OpenAPI definition

```json
{
  "openapi": "3.0.1",
  "info": {
    "title": "Wrike API",
    "version": "4.0"
  },
  "servers": [
    {
      "url": "https://www.wrike.com/api/v4"
    },
    {
      "url": "https://app-eu.wrike.com/api/v4"
    },
    {
      "url": "https://app-us2.wrike.com/api/v4"
    }
  ],
  "paths": {
    "/tasks": {
      "get": {
        "tags": [
          "Tasks"
        ],
        "summary": "Get Tasks (Account)",
        "description": "Search among all tasks in current account.\n\n<b>Scopes:</b> Default, wsReadOnly, wsReadWrite",
        "operationId": "GET:/tasks/empty",
        "parameters": [
          {
            "name": "descendants",
            "in": "query",
            "description": "Adds all descendant folders to search scope. Applicable only for GET/folders/{folderId}/tasks and GET/spaces/{spaceId}/tasks endpoints",
            "required": false,
            "schema": {
              "type": "boolean",
              "description": "Adds all descendant folders to search scope. Applicable only for GET/folders/{folderId}/tasks and GET/spaces/{spaceId}/tasks endpoints"
            }
          },
          {
            "name": "title",
            "in": "query",
            "description": "Title filter, contains match",
            "required": false,
            "schema": {
              "type": "string",
              "description": "Title filter, contains match"
            }
          },
          {
            "name": "status",
            "in": "query",
            "description": "Status filter, match with any of specified constants\n* `Active` - Active\n* `Deferred` - Deferred\n* `Completed` - Completed\n* `Cancelled` - Cancelled",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Status filter, match with any of specified constants",
                  "items": {
                    "$ref": "#/components/schemas/TaskStatus"
                  }
                }
              }
            }
          },
          {
            "name": "importance",
            "in": "query",
            "description": "Importance filter, exact match\n* `High`\n* `Low`\n* `Normal`",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/TaskImportance"
            }
          },
          {
            "name": "startDate",
            "in": "query",
            "description": "Start date filter, date match or range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LocalDateTimeRange"
                }
              }
            }
          },
          {
            "name": "dueDate",
            "in": "query",
            "description": "Due date filter, date match or range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LocalDateTimeRange"
                }
              }
            }
          },
          {
            "name": "scheduledDate",
            "in": "query",
            "description": "Scheduled date filter. Both dates should be set in ranged version.\nReturns all tasks that have schedule intersecting with specified interval, date match or range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LocalDateRange"
                }
              }
            }
          },
          {
            "name": "createdDate",
            "in": "query",
            "description": "Created date filter, range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InstantRange"
                }
              }
            }
          },
          {
            "name": "updatedDate",
            "in": "query",
            "description": "Updated date filter, range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InstantRange"
                }
              }
            }
          },
          {
            "name": "completedDate",
            "in": "query",
            "description": "Completed date filter, range",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/InstantRange"
                }
              }
            }
          },
          {
            "name": "authors",
            "in": "query",
            "description": "Authors filter, match of any",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Authors filter, match of any",
                  "items": {
                    "$ref": "#/components/schemas/UserId"
                  }
                }
              }
            }
          },
          {
            "name": "responsibles",
            "in": "query",
            "description": "Assignees filter with specified users or invitations, match of any",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Assignees filter with specified users or invitations, match of any",
                  "items": {
                    "$ref": "#/components/schemas/UserId"
                  }
                }
              }
            }
          },
          {
            "name": "responsiblePlaceholders",
            "in": "query",
            "description": "Assignee Placeholders filter, match of any",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Assignee Placeholders filter, match of any",
                  "items": {
                    "$ref": "#/components/schemas/PlaceholderId"
                  }
                }
              }
            }
          },
          {
            "name": "permalink",
            "in": "query",
            "description": "Task permalink, exact match",
            "required": false,
            "schema": {
              "type": "string",
              "description": "Task permalink, exact match"
            }
          },
          {
            "name": "type",
            "in": "query",
            "description": "Task type\n* `Milestone`\n* `Backlog`\n* `Planned`",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/TaskDatesType"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "description": "Limit on number of returned tasks",
            "required": false,
            "schema": {
              "type": "number",
              "description": "Limit on number of returned tasks"
            }
          },
          {
            "name": "sortField",
            "in": "query",
            "description": "Sort field\n* `Status` - Sort by status\n* `Importance` - Sort by importance\n* `UpdatedDate` - Sort by updated date\n* `CreatedDate` - Sort by created date\n* `Title` - Lexicographic sorting by title\n* `StartFinishInterval` - Sort by start-finish interval\n* `DueDate` - Sort by due date\n* `LastAccessDate` - Sort by last access date\n* `CompletedDate` - Sort by completed date",
            "required": false,
            "schema": {
              "type": "string",
              "enum": [
                "Status",
                "Importance",
                "UpdatedDate",
                "CreatedDate",
                "Title",
                "StartFinishInterval",
                "DueDate",
                "LastAccessDate",
                "CompletedDate"
              ]
            }
          },
          {
            "name": "sortOrder",
            "in": "query",
            "description": "Sort order\n* `Asc` - Ascending sort order\n* `Desc` - Descending sort order",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/SortOrder"
            }
          },
          {
            "name": "subTasks",
            "in": "query",
            "description": "Adds subtasks to search scope",
            "required": false,
            "schema": {
              "type": "boolean",
              "description": "Adds subtasks to search scope"
            }
          },
          {
            "name": "pageSize",
            "in": "query",
            "description": "The number of tasks to return (max 1000 items per page)",
            "required": false,
            "schema": {
              "type": "number",
              "description": "The number of tasks to return (max 1000 items per page)"
            }
          },
          {
            "name": "nextPageToken",
            "in": "query",
            "description": "A pagination request will return a token that applies an offset to the next page. The returned value should be used as an input parameter in the next request. Parameter pageSize can be omitted in this case. If you included optional fields to the first request, you will need to include those  in each new call",
            "required": false,
            "schema": {
              "type": "string",
              "description": "A pagination request will return a token that applies an offset to the next page. The returned value should be used as an input parameter in the next request. Parameter pageSize can be omitted in this case. If you included optional fields to the first request, you will need to include those  in each new call"
            }
          },
          {
            "name": "metadata",
            "in": "query",
            "description": "Task metadata filter",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Metadata"
                }
              }
            }
          },
          {
            "name": "customField",
            "in": "query",
            "description": "[Deprecated] It is recommended to use 'customFields' parameter. Custom field filter",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CustomFieldFilterParam"
                }
              }
            }
          },
          {
            "name": "customFields",
            "in": "query",
            "description": "Custom field filters, exact match",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Custom field filters, exact match",
                  "items": {
                    "$ref": "#/components/schemas/CustomFieldFilterParam"
                  }
                }
              }
            }
          },
          {
            "name": "customStatuses",
            "in": "query",
            "description": "Custom statuses filter",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Custom statuses filter",
                  "items": {
                    "$ref": "#/components/schemas/CustomStatusId"
                  }
                }
              }
            }
          },
          {
            "name": "withInvitations",
            "in": "query",
            "description": "Include invitations in sharedIds & responsibleIds lists",
            "required": false,
            "schema": {
              "type": "boolean",
              "description": "Include invitations in sharedIds & responsibleIds lists"
            }
          },
          {
            "name": "billingTypes",
            "in": "query",
            "description": "Timelog billing types filter\n* `Billable` - Billable\n* `NonBillable` - Non-Billable",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Timelog billing types filter",
                  "items": {
                    "$ref": "#/components/schemas/BillingType"
                  }
                }
              }
            }
          },
          {
            "name": "plainTextCustomFields",
            "in": "query",
            "description": "Strip HTML tags from custom fields",
            "required": false,
            "schema": {
              "type": "boolean",
              "description": "Strip HTML tags from custom fields"
            }
          },
          {
            "name": "customItemTypes",
            "in": "query",
            "description": "Custom item types filter. Standard type (task) ID is not allowed. Filtering by deleted custom item types is not supported. Limit : `1000`",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "maxItems": 1000,
                  "type": "array",
                  "description": "Custom item types filter. Standard type (task) ID is not allowed. Filtering by deleted custom item types is not supported.",
                  "items": {
                    "$ref": "#/components/schemas/EntityTypeId"
                  }
                }
              }
            }
          },
          {
            "name": "fields",
            "in": "query",
            "description": "Json string array of optional fields to be included in the response model\n* `metadata` - Task metadata entries\n* `responsibleIds` - List of assignee user IDs\n* `customItemTypeId` - Work Item custom item type Id\n* `customFields` - Custom fields\n* `followerIds` - List of user IDs, who follows task, and the additional flag \"followedByMe\", that indicates if a task is followed by user\n* `parentIds` - List of task parent folder\n* `sharedIds` - List of user IDs, who have task share\n* `description` - Description\n* `superTaskIds` - List of supertask IDs\n* `responsiblePlaceholderIds` - List of placeholder assignee IDs\n* `superParentIds` - List of folder IDs inherited from parent task\n* `dependencyIds` - Dependency IDs\n* `billingType` - Billing type\n* `attachmentCount` - Attachment count\n* `workScheduleId` - Id of work schedule assigned to task\n* `effortAllocation` - Effort Allocation\n* `hasAttachments` - Has attachments\n* `subTaskIds` - List of subtask IDs\n* `recurrent` - Is a task recurrent\n* `authorIds` - Author IDs\n* `briefDescription` - Brief description",
            "required": false,
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "description": "Json string array of optional fields to be included in the response model",
                  "items": {
                    "type": "string",
                    "enum": [
                      "metadata",
                      "responsibleIds",
                      "customItemTypeId",
                      "customFields",
                      "followerIds",
                      "parentIds",
                      "sharedIds",
                      "description",
                      "superTaskIds",
                      "responsiblePlaceholderIds",
                      "superParentIds",
                      "dependencyIds",
                      "billingType",
                      "attachmentCount",
                      "workScheduleId",
                      "effortAllocation",
                      "hasAttachments",
                      "subTaskIds",
                      "recurrent",
                      "authorIds",
                      "briefDescription"
                    ]
                  }
                }
              }
            }
          }
        ],
        "responses": {
          "2XX": {
            "description": "success response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "data": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/Task"
                      }
                    },
                    "kind": {
                      "$ref": "#/components/schemas/ResponseKind"
                    }
                  }
                }
              }
            }
          },
          "4XX": {
            "description": "client-side error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "5XX": {
            "description": "server-side error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        },
        "security": [
          {
            "HTTP": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "ResponseKind": {
        "type": "string",
        "enum": [
          "accounts",
          "users",
          "contacts",
          "assets",
          "eDiscoveryReport",
          "folders",
          "folderTree",
          "tasks",
          "taskIds",
          "timelogs",
          "timelogCategories",
          "timelogLockPeriods",
          "timetrackerTimers",
          "comments",
          "attachments",
          "url",
          "version",
          "dataExport",
          "dataExportSchema",
          "auditLog",
          "accessRoles",
          "stream",
          "changes",
          "posts",
          "mailSettings",
          "integrationInfo",
          "gmailIntegrationSettings",
          "workTypesForIntegrations",
          "ids",
          "backups",
          "domains",
          "dependencies",
          "workflows",
          "workschedules",
          "workscheduleExclusions",
          "workscheduleUserExclusions",
          "customfields",
          "customfieldIds",
          "customstatuses",
          "invitations",
          "notifications",
          "jobroles",
          "placeholders",
          "groups",
          "session",
          "dashboards",
          "widgets",
          "taskCreationSettings",
          "colors",
          "experiments",
          "topics",
          "topicComments",
          "webhooks",
          "reviews",
          "boards",
          "textSearch",
          "chatChannels",
          "chatMessages",
          "forms",
          "requestForms",
          "request",
          "report",
          "platformWidgets",
          "platformWidgetInstances",
          "spaces",
          "pdf",
          "customerSatisfaction",
          "asyncJob",
          "approvals",
          "highlights",
          "highlightsList",
          "highlightsSettings",
          "highlightsCard",
          "timesheet",
          "timesheetRow",
          "timesheetSubmissionRule",
          "mobileFeatures",
          "mobileSettings",
          "folderBlueprintTree",
          "taskBlueprintTree",
          "feedback",
          "timeline_snapshot",
          "contactIds",
          "bookings",
          "integrateThreshold",
          "hourlyRatesProvision",
          "hourlyRates",
          "projectTeamMembers",
          "contactsHistory",
          "tasksHistory",
          "foldersHistory",
          "activityDigest",
          "workItemTemplates",
          "workTemplates",
          "workItemMetadata",
          "workItem",
          "customItemTypes",
          "verificationCode",
          "views",
          "listView",
          "tableView",
          "userTypes",
          "reactions",
          "externalRequesters",
          "workscheduleCapacityOverrides",
          "userCapacityOverrides",
          "userCapacityExclusions",
          "rollups",
          "requestFormPrefill",
          "cascadingFieldSettings"
        ]
      },
      "CustomFieldId": {
        "pattern": "^([A-Z0-9]){16}$",
        "type": "string"
      },
      "InstantRange": {
        "type": "object",
        "properties": {
          "start": {
            "type": "string",
            "description": "Range start<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          },
          "end": {
            "type": "string",
            "description": "Range end<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          }
        }
      },
      "DependencyId": {
        "pattern": "^([a-zA-Z0-9-_:\\.=]){1,256}$",
        "type": "string"
      },
      "Metadata": {
        "required": [
          "key",
          "value"
        ],
        "type": "object",
        "properties": {
          "value": {
            "type": "string",
            "description": "Value should be less than 1000 symbols, compatible with JSON string. Use JSON 'null' in order to remove metadata entry"
          },
          "key": {
            "type": "string",
            "description": "Key should be less than 50 symbols and match following regular expression ([A-Za-z0-9_-]+)"
          }
        },
        "description": "Metadata entries are isolated on per-client (application) basis"
      },
      "CustomFieldComparator": {
        "type": "string",
        "description": "* `IsEmpty` - For all field types. No extra parameters required\n* `ContainsAny` - For multiple select and contact fields. Parameter 'values' is required\n* `NotInRange` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameters 'minValue' and 'maxValue' are required\n* `LessOrEqualTo` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameter 'value' is required\n* `StartsWith` - For text and dropdown fields. Parameter 'value' is required\n* `ContainsAll` - For multiple select and contact fields. Parameter 'values' is required\n* `EqualTo` - For all field types. Parameter 'value' is required\n* `LessThan` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameter 'value' is required\n* `GreaterOrEqualTo` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameter 'value' is required\n* `IsNotEmpty` - For all field types. No extra parameters required\n* `GreaterThan` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameter 'value' is required\n* `InRange` - For numeric, text, dropdown, currency, percent, duration, and date fields. Parameters 'minValue' and 'maxValue' are required\n* `Contains` - For text and dropdown fields. Parameter 'value' is required\n* `EndsWith` - For text and dropdown fields. Parameter 'value' is required",
        "enum": [
          "IsEmpty",
          "ContainsAny",
          "NotInRange",
          "LessOrEqualTo",
          "StartsWith",
          "ContainsAll",
          "EqualTo",
          "LessThan",
          "GreaterOrEqualTo",
          "IsNotEmpty",
          "GreaterThan",
          "InRange",
          "Contains",
          "EndsWith"
        ]
      },
      "ErrorType": {
        "type": "string",
        "enum": [
          "invalid_request",
          "invalid_parameter",
          "parameter_required",
          "not_authorized",
          "access_forbidden",
          "not_allowed",
          "resource_not_found",
          "method_not_found",
          "too_many_requests",
          "rate_limit_exceeded",
          "server_error"
        ]
      },
      "EntityTypeId": {
        "pattern": "^([A-Z0-9]){16}$",
        "type": "string"
      },
      "ErrorResponse": {
        "type": "object",
        "properties": {
          "errorDescription": {
            "type": "string"
          },
          "error": {
            "$ref": "#/components/schemas/ErrorType"
          }
        }
      },
      "LocalDateTimeRange": {
        "type": "object",
        "properties": {
          "equal": {
            "type": "string",
            "description": "Date exact match value<br>Format: yyyy-MM-dd'T'HH:mm:ss ('T'HH:mm:ss is optional)"
          },
          "start": {
            "type": "string",
            "description": "Range start<br>Format: yyyy-MM-dd'T'HH:mm:ss ('T'HH:mm:ss is optional)"
          },
          "end": {
            "type": "string",
            "description": "Range end<br>Format: yyyy-MM-dd'T'HH:mm:ss ('T'HH:mm:ss is optional)"
          }
        }
      },
      "AccountId": {
        "pattern": "^([A-Z0-9]){8}$",
        "type": "string"
      },
      "CustomFieldFilterParam": {
        "required": [
          "id"
        ],
        "type": "object",
        "properties": {
          "comparator": {
            "$ref": "#/components/schemas/CustomFieldComparator"
          },
          "minValue": {
            "type": "string",
            "description": "Custom field min value"
          },
          "maxValue": {
            "type": "string",
            "description": "Custom field max value"
          },
          "values": {
            "type": "array",
            "description": "Custom field possible values",
            "items": {
              "type": "string"
            }
          },
          "id": {
            "$ref": "#/components/schemas/CustomFieldId"
          },
          "value": {
            "type": "string",
            "description": "Custom field value"
          }
        }
      },
      "BillingType": {
        "type": "string",
        "description": "* `Billable` - Billable\n* `NonBillable` - Non-Billable",
        "enum": [
          "Billable",
          "NonBillable"
        ]
      },
      "PlaceholderId": {
        "pattern": "^([A-Z0-9]){16}$",
        "type": "string"
      },
      "LocalDateRange": {
        "type": "object",
        "properties": {
          "equal": {
            "type": "string",
            "description": "Date exact match value<br>Format: yyyy-MM-dd"
          },
          "start": {
            "type": "string",
            "description": "Range start<br>Format: yyyy-MM-dd"
          },
          "end": {
            "type": "string",
            "description": "Range end<br>Format: yyyy-MM-dd"
          }
        }
      },
      "TaskEffort": {
        "required": [
          "mode"
        ],
        "type": "object",
        "properties": {
          "dailyAllocationPercentage": {
            "type": "number",
            "description": "Allocation in percentages per day, for effort daily mode"
          },
          "mode": {
            "$ref": "#/components/schemas/EffortMode"
          },
          "allocatedEffort": {
            "type": "number",
            "description": "Allocated Effort in minutes"
          },
          "totalEffort": {
            "type": "number",
            "description": "Total Effort in minutes"
          },
          "responsibleAllocation": {
            "type": "array",
            "description": "Responsible allocations by day",
            "items": {
              "$ref": "#/components/schemas/ResponsibleAllocation"
            }
          }
        }
      },
      "FolderId": {
        "pattern": "^([a-zA-Z0-9-_:\\.=]){1,256}$",
        "type": "string"
      },
      "TaskId": {
        "pattern": "^([a-zA-Z0-9-_:\\.=]){1,256}$",
        "type": "string"
      },
      "DailyAllocation": {
        "required": [
          "date",
          "effortMinutes"
        ],
        "type": "object",
        "properties": {
          "date": {
            "type": "string",
            "description": "Allocation date<br>Format: yyyy-MM-dd"
          },
          "effortMinutes": {
            "type": "number",
            "description": "Effort in minutes"
          }
        }
      },
      "TaskDates": {
        "type": "object",
        "properties": {
          "duration": {
            "type": "number",
            "description": "Duration in minutes. Duration is present in Planned tasks and is optional for Backlog tasks.<br>\nWhen updating duration, ensure to re-submit the start and due dates, even if they are to stay the same. Otherwise, the dates will be cleared.<br>\nWhen present for Planned tasks and due date is not given, this field limit is [1, 1800000).<br>\nNote that 1 day in Wrike is equal to 8 hours, or 480 minutes."
          },
          "due": {
            "type": "string",
            "description": "Due date is present only in Planned and Milestone tasks. When setting this field alone, the task will default to a milestone.<br>Format: yyyy-MM-dd'T'HH:mm:ss ('T'HH:mm:ss is optional)"
          },
          "start": {
            "type": "string",
            "description": "Start date is present only in Planned tasks. Important: If setting a start date, always include either a due date or duration.<br>Format: yyyy-MM-dd'T'HH:mm:ss ('T'HH:mm:ss is optional)"
          },
          "workOnWeekends": {
            "type": "boolean",
            "description": "Weekends are included in task scheduling"
          },
          "type": {
            "$ref": "#/components/schemas/TaskDatesType"
          }
        },
        "description": "Field values limits:\nduration - [0, 1800000)\nstart & due - [1970-01-01T00:00:00, 2100-01-01T00:00:00)"
      },
      "TaskDatesType": {
        "type": "string",
        "description": "* `Milestone`\n* `Backlog`\n* `Planned`",
        "enum": [
          "Milestone",
          "Backlog",
          "Planned"
        ]
      },
      "TaskFinance": {
        "type": "object",
        "properties": {
          "plannedCost": {
            "type": "number",
            "description": "Planned cost"
          },
          "plannedFees": {
            "type": "number",
            "description": "Planned fees"
          },
          "currency": {
            "type": "string",
            "description": "Currency"
          },
          "actualFees": {
            "type": "number",
            "description": "Actual fees"
          },
          "actualCost": {
            "type": "number",
            "description": "Actual cost"
          }
        }
      },
      "EffortMode": {
        "type": "string",
        "description": "* `Basic`\n* `Flexible`\n* `FullTime`\n* `None`",
        "enum": [
          "Basic",
          "Flexible",
          "FullTime",
          "None"
        ]
      },
      "TaskStatus": {
        "type": "string",
        "description": "* `Active` - Active\n* `Deferred` - Deferred\n* `Completed` - Completed\n* `Cancelled` - Cancelled",
        "enum": [
          "Active",
          "Deferred",
          "Completed",
          "Cancelled"
        ]
      },
      "ResponsibleAllocation": {
        "required": [
          "dailyAllocation"
        ],
        "type": "object",
        "properties": {
          "placeholderId": {
            "$ref": "#/components/schemas/PlaceholderId"
          },
          "dailyAllocation": {
            "type": "array",
            "description": "Daily allocations",
            "items": {
              "$ref": "#/components/schemas/DailyAllocation"
            }
          },
          "userId": {
            "$ref": "#/components/schemas/UserId"
          }
        }
      },
      "Task": {
        "type": "object",
        "properties": {
          "metadata": {
            "type": "array",
            "description": "List of task metadata entries",
            "items": {
              "$ref": "#/components/schemas/Metadata"
            }
          },
          "importance": {
            "$ref": "#/components/schemas/TaskImportance"
          },
          "customFields": {
            "type": "array",
            "description": "Custom fields",
            "items": {
              "$ref": "#/components/schemas/CustomField"
            }
          },
          "followerIds": {
            "type": "array",
            "description": "List of user IDs, who follows task",
            "items": {
              "$ref": "#/components/schemas/UserId"
            }
          },
          "parentIds": {
            "type": "array",
            "description": "List of task parent folder IDs",
            "items": {
              "$ref": "#/components/schemas/FolderId"
            }
          },
          "description": {
            "type": "string",
            "description": "Description"
          },
          "responsiblePlaceholderIds": {
            "type": "array",
            "description": "List of placeholder assignee Ids",
            "items": {
              "$ref": "#/components/schemas/PlaceholderId"
            }
          },
          "updatedDate": {
            "type": "string",
            "description": "Updated date<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          },
          "title": {
            "type": "string",
            "description": "Title, cannot be empty"
          },
          "followedByMe": {
            "type": "boolean",
            "description": "Is a task followed by me"
          },
          "billingType": {
            "$ref": "#/components/schemas/BillingType"
          },
          "scope": {
            "$ref": "#/components/schemas/TreeScope"
          },
          "id": {
            "$ref": "#/components/schemas/TaskId"
          },
          "effortAllocation": {
            "$ref": "#/components/schemas/TaskEffort"
          },
          "hasAttachments": {
            "type": "boolean",
            "description": "Has attachments"
          },
          "subTaskIds": {
            "type": "array",
            "description": "List of subtask IDs",
            "items": {
              "$ref": "#/components/schemas/TaskId"
            }
          },
          "recurrent": {
            "type": "boolean",
            "description": "Is a task recurrent"
          },
          "authorIds": {
            "type": "array",
            "description": "List of author IDs (currently contains 1 element)",
            "items": {
              "$ref": "#/components/schemas/UserId"
            }
          },
          "responsibleIds": {
            "type": "array",
            "description": "List of assignee user IDs",
            "items": {
              "$ref": "#/components/schemas/UserId"
            }
          },
          "customItemTypeId": {
            "$ref": "#/components/schemas/EntityTypeId"
          },
          "sharedIds": {
            "type": "array",
            "description": "Users with whom the task is shared",
            "items": {
              "$ref": "#/components/schemas/UserId"
            }
          },
          "dates": {
            "$ref": "#/components/schemas/TaskDates"
          },
          "superTaskIds": {
            "type": "array",
            "description": "List of super task IDs",
            "items": {
              "$ref": "#/components/schemas/TaskId"
            }
          },
          "priority": {
            "type": "string",
            "description": "Ordering key that defines task order in tasklist"
          },
          "completedDate": {
            "type": "string",
            "description": "Completed date<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          },
          "superParentIds": {
            "type": "array",
            "description": "List of folder IDs inherited from parent task",
            "items": {
              "$ref": "#/components/schemas/FolderId"
            }
          },
          "accountId": {
            "$ref": "#/components/schemas/AccountId"
          },
          "dependencyIds": {
            "type": "array",
            "description": "List of dependency IDs",
            "items": {
              "$ref": "#/components/schemas/DependencyId"
            }
          },
          "createdDate": {
            "type": "string",
            "description": "Created date<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          },
          "cascadingFieldSettings": {
            "type": "array",
            "description": "Cascading field settings",
            "items": {
              "$ref": "#/components/schemas/CascadingFieldSettings"
            }
          },
          "customStatusId": {
            "$ref": "#/components/schemas/CustomStatusId"
          },
          "attachmentCount": {
            "type": "number",
            "description": "Total count of task attachments"
          },
          "workScheduleId": {
            "$ref": "#/components/schemas/WorkScheduleId"
          },
          "permalink": {
            "type": "string",
            "description": "Link to open task in web workspace, if user has appropriate access"
          },
          "briefDescription": {
            "type": "string",
            "description": "Brief description"
          },
          "finance": {
            "$ref": "#/components/schemas/TaskFinance"
          },
          "status": {
            "$ref": "#/components/schemas/TaskStatus"
          }
        }
      },
      "CustomStatusId": {
        "pattern": "^([A-Z0-9]){16}$",
        "type": "string"
      },
      "WorkScheduleId": {
        "pattern": "^([A-Z0-9]){16}$",
        "type": "string"
      },
      "TreeScope": {
        "type": "string",
        "description": "* `WsTask` - Task in account\n* `RbRoot` - Virtual Recycle Bin folder of account\n* `RbFolder` - Folder is in Recycle Bin (deleted folder)\n* `WsFolder` - Folder in account\n* `WsRoot` - Virtual root folder of account\n* `RbTask` - Task is in Recycle Bin (deleted task)",
        "enum": [
          "WsTask",
          "RbRoot",
          "RbFolder",
          "WsFolder",
          "WsRoot",
          "RbTask"
        ]
      },
      "TaskImportance": {
        "type": "string",
        "description": "* `High`\n* `Low`\n* `Normal`",
        "enum": [
          "High",
          "Low",
          "Normal"
        ]
      },
      "CascadingFieldSettings": {
        "type": "object",
        "properties": {
          "systemField": {
            "type": "boolean",
            "description": "System field"
          },
          "enabledBy": {
            "$ref": "#/components/schemas/UserId"
          },
          "enabledAt": {
            "type": "string",
            "description": "Enabled at<br>Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
          },
          "fieldId": {
            "$ref": "#/components/schemas/CustomFieldId"
          }
        }
      },
      "SortOrder": {
        "type": "string",
        "description": "* `Asc` - Ascending sort order\n* `Desc` - Descending sort order",
        "enum": [
          "Asc",
          "Desc"
        ]
      },
      "UserId": {
        "pattern": "^([A-Z0-9]){8}$",
        "type": "string"
      },
      "CustomField": {
        "required": [
          "id",
          "value"
        ],
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/CustomFieldId"
          },
          "value": {
            "type": "string",
            "description": "Custom field value. 4000 characters max. Should be valid string according to JSON RFC 8259. In particular, following characters must be escaped: quotation mark, reverse solidus, and the control characters (U+0000 through U+001F). Any character may be escaped, but unnecessarily escaped character can be implicitly translated to it's unescaped version. <br> In addition to RFC 8259 requirements, it is not recommended to use any of control characters in CF value.<br>Wrike's API forbids using U+0000 in every place and U+0011 at the beginning of the CF value string.<br>The correct way for setting multiple values in the multiple select Custom fields is ?customFields=[{\"id\":\"CustomFieldId\",\"value\":\"[\\\"value1\\\",\\\"value2\\\"]\"}]<br>The correct way for setting values in the people Custom fields is ?customFields=[{\"id\":\"CustomFieldId\",\"value\":\"UserId1, UserId2\"}]<br> Note that if custom field values are passed to API as URI param of request, they must be URI encoded. Here are some examples:<br>\"%5c\" - reverse solidus (backslash)<br>\"%5c%22\" - quotation mark<br>\"Vi%5Cu1ec7t\" - unicode-escaped character in word \"Việt\"<br>"
          }
        }
      }
    },
    "securitySchemes": {
      "HTTP": {
        "type": "http",
        "description": "Use OAuth 2.0 access token or permanent access token for authorization.",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      }
    }
  }
}
```