The authenticated Yandex Tracker user (a safe auth probe).

A single Tracker issue by key.

Issues matching the supplied filters (omitted filters dropped), auto-paginated.

Returns at most limit issues; exactly limit back means more may match — narrow the filters or raise limit.

Issues matching a query-language string or a filter, auto-paginated.

body.query is a TQL string, body.filter a field → value object. Returns at most limit issues; exactly limit back means more may match — refine the search or raise limit. E.g. {"body": {"query": "Queue: QUEUE Status: open"}} or {"body": {"filter": {"queue": "QUEUE", "assignee": "ann"}}}.

Count of issues matching a query-language string or a filter.

body.query is a TQL string, body.filter a field → value object; an empty body counts every issue the caller can see. E.g. {"body": {"filter": {"queue": "QUEUE", "status": "open"}}}.

Typeahead over visible issues — issues whose summary contains text.

A lightweight title match; for full TQL search use issues_search.

Create a Tracker issue; returns the new issue with its key.

Update fields of a Tracker issue; only the keys present in body are changed.

Status is NOT changed here — use transitions_execute. Returns the updated issue.

Move a Tracker issue to another queue (it gets a new key there; the old key redirects).

queue is the target queue key. Fields that do not exist in the target queue may be dropped. Returns the moved issue with its new key.

Release the server resources of a scrolled issue search (harmless housekeeping).

body maps each X-Scroll-Id to its X-Scroll-Token from a scrolled issues.search response. Returns an acknowledgement on success.

Start an async bulk field update over many Tracker issues; returns the operation.

Poll the returned operation id with bulk_get and inspect failures with bulk_issues_list.

Start an async bulk move of many Tracker issues to another queue; returns the operation.

Poll with bulk_get.

Start an async bulk status transition over many Tracker issues; returns the operation.

Poll with bulk_get.

Import an issue preserving its original history (admin-only back-fill).

Returns the imported issue.

All comments on a Tracker issue, auto-paginated via the relative id-cursor.

Capped at the configured item cap unless limit is given, so very long threads are truncated at the cap rather than fetched forever.

One comment of a Tracker issue: text, author, edit history and, on request, attachments.

Add a comment to a Tracker issue; returns the created comment.

Replace the text of an existing comment on a Tracker issue.

Get comment_id from comments_list. Returns the updated comment.

Permanently delete one comment from a Tracker issue (irreversible).

Get comment_id from comments_list. Returns an acknowledgement on success.

Add an emoji reaction to a comment on a Tracker issue.

name is the reaction name (e.g. like, dislike, fire). Returns the comment with its updated reactions.

Import a comment onto an issue preserving its original author and timestamp (admin-only).

Returns the imported comment.

All links on a Tracker issue (linked issues, type, direction).

Links of a Tracker issue filtered by type, paged and capped (a read done via POST).

Prefer this over links_list for issues with many links or when only some link types or fields matter; it carries each link's author, dates, assignee and status.

Link a Tracker issue to another issue; returns the created link.

Remove a link between two Tracker issues (irreversible).

Get link_id from links_list. Returns an acknowledgement on success.

Import an issue link preserving its original creation metadata (admin-only).

Returns the imported link.

Available workflow transitions for a Tracker issue.

Move a Tracker issue through a workflow transition (change its status).

Get transition_id from transitions_list. body may be empty or carry issue fields to set on transition, e.g. a resolution when closing. Returns the transitions available from the new status.

All time-tracking entries logged against a single Tracker issue.

Auto-paginated via the relative id-cursor. Capped at the configured item cap unless limit is given.

Scoped to one issue by issue_key. To search worklog across the whole org (by author and/or a creation-time range) use worklog_search instead.

Org-wide worklog entries filtered by author and/or a creation-time range.

Unlike worklog_list (one issue), this searches every issue's worklog. body.createdBy scopes to a user and body.createdAt to a time window; both are optional. E.g. {"body": {"createdBy": "ann", "createdAt": {"from": "2026-01-01T00:00:00"}}}.

Org-wide worklog entries via GET /worklog query filters (author, creation time).

A lighter sibling of worklog_search; every filter is optional.

Log spent time on a Tracker issue; returns the created worklog record.

Edit a worklog record on a Tracker issue (duration and/or comment).

Get record_id from worklog_list. Returns the updated record.

Permanently delete a worklog record from a Tracker issue (irreversible).

Get record_id from worklog_list. Returns an acknowledgement on success.

Import a worklog record preserving its original author and timestamps (admin-only).

Returns the imported record(s) — the endpoint answers with a JSON array.

Full changelog (edit history) for a Tracker issue.

Auto-paginated via the relative id-cursor. Capped at the configured item cap unless limit is given.

The checklist items on a Tracker issue (text, done flag, assignee, per-item deadline).

Returns a flat array; an issue with no checklist yields an empty list. Item ids from here feed checklists_update / checklists_delete.

Add an item to a Tracker issue's checklist (creates the checklist if absent).

Returns the issue with its full checklist.

Edit one checklist item on a Tracker issue (text, checked state, assignee, deadline).

Get item_id from checklists_list. Returns the issue with its updated checklist.

Permanently remove one item from a Tracker issue's checklist (irreversible).

Get item_id from checklists_list. Returns the issue with its remaining checklist.

Permanently delete the ENTIRE checklist of a Tracker issue (all items, irreversible).

Returns the issue without its checklist.

Every column defined on the given agile board.

Each column carries the issue statuses whose cards land in it. Use this to inspect a board's column layout; use columns_get when you already know a column id, and boards_get for the board itself.

Look up a single board column by its numeric id.

The column includes the issue statuses grouped into it. Use this when you already know the board and column ids; use columns_list to enumerate every column on a board.

Add a column to an agile board; returns the new column.

name and statuses (the issue-status keys whose cards land in the column) are required; limit optionally caps the number of issues allowed in the column.

Edit a board column; only the fields set in body are changed.

Get column_id from columns_list. Returns the updated column.

Permanently remove a column from an agile board (irreversible).

Returns an acknowledgement on success.

All available issue priorities in the organisation.

Create an org-global issue priority.

CAUTION: priorities are organisation-wide and have no delete endpoint — creation leaves permanent residue. key is the latin identifier; name holds the ru/en display names.

Edit an issue priority; only the fields set in body are changed.

priority_id is the numeric id (not the key). Pass version to guard against concurrent edits (optimistic locking).

All available issue types (e.g. task, bug, epic).

Create an org-global issue type (e.g. a new kind of task).

CAUTION: issue types are organisation-wide and have no delete endpoint — creation leaves permanent residue. key is the latin identifier; name holds the ru/en display names.

Edit an org-global issue type; only the fields set in body are changed.

issue_type_id is the numeric id (not the key). Pass version to guard against concurrent edits (optimistic locking).

All available link types (e.g. relates, depends on, blocks).

Look up a single organisation user account by login or uid.

The account includes name, email and licence/dismissal status. Use this when you already know one user; use users_list to browse or enumerate the whole directory. Pass expand="groups" to include the user's groups.

All users registered in the organisation, sorted by ascending uid.

Auto-paginated via the relative id-cursor. Capped at the configured item cap unless limit is given; use users_get instead when you already know the specific login or uid.

Every issue status configured in the organisation's workflows.

Each status has a key, a name and a type such as new/inProgress/done. Use this to resolve or validate a status key before filtering or transitioning issues; see resolutions_list for close-out results and priorities_list for priorities.

Create an org-global issue status for use in workflows.

CAUTION: statuses are organisation-wide and have no delete endpoint — creation leaves permanent residue. key is the latin identifier, name holds the ru/en display names, type is the stage kind (new/inProgress/paused/done/cancelled).

Edit an issue status; only the fields set in body are changed.

status_id is the numeric id (not the key). Pass version to guard against concurrent edits (optimistic locking).

Every issue resolution configured in the organisation.

A resolution is the close-out result such as fixed/duplicate/won't-fix. Use this to resolve or validate a resolution key when reading a closed issue or filtering; see statuses_list for workflow stages, not close-out reasons.

Create an org-global issue resolution (a close-out reason such as fixed/duplicate).

CAUTION: resolutions are organisation-wide and have no delete endpoint — creation leaves permanent residue. key is the latin identifier; name holds the ru/en display names.

Edit an issue resolution; only the fields set in body are changed.

resolution_id is the numeric id (not the key). Pass version to guard against concurrent edits (optimistic locking).

Every queue the caller can see, auto-paginated over the API's page/perPage pages.

Capped at the configured item cap unless limit is given. Each item's key is the queue key (e.g. TEST) you pass to queues_get and use as an issue prefix (TEST-123). Use queues_get for a single queue's full configuration (types, workflows, resolutions).

One queue's settings and configuration by key or id.

Returns the queue's owner, default type/priority, and — when expand is set — its issue types, versions, team, workflows and per-type resolution config. Sibling queues_list enumerates every queue; pass one of its key values here.

Every tag name that has been added to the queue, as a flat string array.

These are the tags selectable on the queue's issues (the tags field). Remove one everywhere with queues_tags_delete.

The queue's versions — release milestones issues can be assigned to.

Each item carries the version's name, date range and released/archived flags. Create one with queues_versions_create.

The queue's required/local fields with their schema, options and display order.

Use this to learn which fields an issue in the queue expects (and whether each is required) before creating or updating issues there.

Create a Tracker queue (the container issues live in; its key prefixes issue keys).

Required: key (latin, uppercase), name, lead (login), default_type (issue type key, e.g. task) and default_priority (priority key, e.g. normal). Returns the new queue.

Delete a Tracker queue WITH ALL ITS ISSUES (recoverable via queues_restore).

The queue moves to the recycle bin and can be restored for a limited time. Returns an acknowledgement on success.

Restore a previously deleted Tracker queue (and its issues) from the recycle bin.

Returns the restored queue.

Replace access rules on a Tracker queue (grant/revoke read/write/create/grant rights).

Each right block takes users/groups/roles arrays; omitted blocks stay unchanged. Returns the resulting permission set. A removal is not always the inverse of an addition: taking a user out of read took it out of write too (seen once, 2026-10-06), so read the returned set after a removal. Adding a member that is there already changes nothing.

Remove a tag from EVERY issue of a queue (irreversible; the tag disappears queue-wide).

body is {"tag": "<name>"} — pick the name from queues_tags_list. Returns an acknowledgement on success.

Create a version (release milestone) on a queue.

Required: queue (the queue key) and name; optional description, start_date / due_date (YYYY-MM-DD). Returns the new version.

One queue version: name, description, dates and its released/archived flags.

Edit a queue version; only the fields set in body change. Returns the version.

Permanently delete a queue version (irreversible). Returns an acknowledgement.

What one user may do in a queue (create, read, write, grant, deny) and why.

Each right lists who grants it: the user personally, a group or a role. To change rights use queues_permissions_update.

What one group may do in a queue (create, read, write, grant, deny).

Custom fields scoped to one queue (its local fields), as a flat list.

Each item's key is the field key you pass to localfields_get; field_schema describes the value type. Local fields differ from global fields (fields_list) in that they exist only inside the given queue. Pass a key from queues_list as queue_id.

One local field's full definition (type, options, category) by queue and field key.

Returns the value schema, allowed-values provider and category of the field. Use localfields_list first to discover the field_key values available in a queue.

Create a custom field scoped to one queue (a local field).

Required fields: id (latin key), name (ru/en display names), category (a category id from fields_list) and type (value type, e.g. ru.yandex.startrek.core.fields. StringFieldType). There is no delete endpoint — the field lives until its queue is deleted.

Edit a queue-local field; only the fields set in body are changed.

Get field_key from localfields_list. Returns the updated field definition.

All global (organisation-wide) issue fields, both standard and custom.

Each field carries its value schema, category and provider metadata. Use this to discover which field keys exist before filtering or reading issues; use fields_get when you already know one field id.

Parameters of a single issue field.

They include its value schema, read-only flag, allowed options and category. Use this when you already know the field id; use fields_list to enumerate every field in the organisation.

Create an org-global custom issue field.

CAUTION: global fields are organisation-wide and NOT deletable — creation leaves permanent residue; prefer localfields_create for a single queue. Required: id (latin key), name (ru/en display names), category (a category id) and type (value type).

Edit an org-global issue field; only the fields set in body are changed.

Pass version to guard against concurrent edits (optimistic locking). Returns the updated field definition.

Create a field category (a grouping bucket for issue fields in the UI).

Required: name (ru/en display names) and order (display weight). CAUTION: org-global and not deletable via the API.

Edit a field category; only the fields set in body are changed.

Pass version to guard against concurrent edits (optimistic locking).

All components created by the organisation's users.

Each component carries its queue, owner and description. Components are sub-areas used to classify issues within a queue; use this to discover valid component names/ids before filtering or creating issues.

Create a component in a queue (a sub-area for classifying its issues).

name and queue (the queue key) are required; optional fields include description, lead and assignAuto.

Edit a component; only the fields set in body are changed.

Get component_id from components_list. Pass version to guard against concurrent edits (optimistic locking).

The components of one queue, so you need not filter components_list by queue.

One component with its queue, owner, description and auto-assign flag.

Permanently delete a component (irreversible). Returns an acknowledgement.

What one user may do on a component (create, read, write, deny) and who grants it.

What one group may do on a component (create, read, write, deny).

Parameters of a single saved issue filter.

They include its stored conditions, query-language string, owner, favourite flag and access permissions. Use this to inspect a filter a user references by id; the resulting conditions can then feed an issues_search query.

Create a saved issue filter owned by the calling user.

name is required; set query (a TQL string) or filter (a conditions object) for the stored search. Remove it later with filters_delete.

Edit a saved issue filter; only the fields set in body are changed.

Get filter_id from filters_get / the Tracker UI. Returns the updated filter.

Permanently delete a saved issue filter (irreversible).

Returns an acknowledgement on success.

External applications that Tracker issues can be linked to via external links.

Use this to discover which application ids/types are available before creating an external link; each application's id and type values are identical.

All agile boards in the organisation, sorted by ascending board id.

Auto-paginated via the relative id-cursor. Capped at the configured item cap unless limit is given. Use boards_get when you know one board id, and sprints_list to list a board's sprints.

Look up a single agile board by its numeric id.

The board includes its columns, estimation field and burndown calendar. Use this when you already know the board id; use boards_list to browse every board, and sprints_list to enumerate the sprints defined on this board.

Create an agile board; returns the new board with its id.

name is required; optional fields include owner, the private/public permissions template, the backlog_available/sprints_available flags and status-backed columns.

Edit an agile board; only the fields set in body are changed.

Supports renaming, toggling backlog_available/sprints_available and replacing the columns layout. Returns the updated board.

Permanently delete an agile board (irreversible; its issues are not affected).

Returns an acknowledgement on success.

Every sprint defined on the given agile board, in the order Tracker returns them.

Each sprint carries its status, planned dates and parent board. Use this to enumerate a board's sprints; use sprints_get when you already know a sprint id, and boards_get for the board itself.

Look up a single sprint by its numeric id.

The sprint includes its status, planned start/end dates, actual start/end datetimes and parent board. Use this when you already know the sprint id; use sprints_list to enumerate all sprints on a board.

Create a sprint on an agile board; returns the new sprint.

Required fields: name, board ({"id": "<board id>"}), start_date and end_date (YYYY-MM-DD). The board must have sprints enabled.

Edit a sprint; only the fields set in body (name, dates) are changed.

Get sprint_id from sprints_list. Pass version (the sprint's current version, from sprints_get) — the API requires it for optimistic locking and answers 428 without one. Returns the updated sprint.

Permanently delete a sprint (irreversible; its issues are not affected).

Returns an acknowledgement on success.

Start a sprint (sets its status to inProgress and stamps the actual start time).

Pass version (the sprint's current version, from sprints_get) — the API requires it for optimistic locking and answers 428 without one. Returns the updated sprint.

Archive a finished sprint (hides it from the board's active sprint list).

Pass version (the sprint's current version, from sprints_get) — the API requires it for optimistic locking and answers 428 without one. Returns the updated sprint.

Files attached to a Tracker issue — name, size, MIME type, uploader, download URLs.

Returns metadata only (an ItemList[Attachment]); use it to discover a file's id and name. Downloading the file's or thumbnail's raw bytes is CLI/SDK-only — run ycli tracker attachments download <ISSUE> <FILE_ID> <FILENAME> — because binary blobs are not an MCP payload.

One attachment's metadata (name, size, MIME type, uploader, download URL).

Downloading the bytes is CLI/SDK-only: ycli tracker attachments download.

Permanently delete one attachment from a Tracker issue (irreversible).

Get file_id from attachments_list. Returns an acknowledgement on success.

Attach a small file to a Tracker issue; returns the created attachment.

The file travels as base64 in the request, so keep it small; for a large file run ycli tracker attachments upload instead.

Upload a small temporary file to attach when creating an issue or a comment.

The returned id goes into attachmentIds of the issue or comment body, and works once. The file travels as base64 in the request, so keep it small.

Import a file onto an issue with its original author and creation time (admin-only).

The file travels as base64 in the request, so keep it small; for a large file run ycli tracker attachments import instead. created_at uses YYYY-MM-DDThh:mm:ss.sss±hhmm. Returns the imported attachment.

Every macro configured on a queue — each a canned comment plus field updates.

Each item's id is what you pass to macros_get for the full body and issueUpdate rows.

One queue macro by id — its comment body and the field updates it applies.

Sibling macros_list enumerates every macro in the queue; pass one of its id values here.

Create a macro on a queue (a canned comment plus field updates applied on demand).

name is required; optional fields are body (the comment template) and fieldChanges rows. Returns the new macro.

Edit a queue macro; only the fields set in body are changed.

Get macro_id from macros_list. Returns the updated macro.

Permanently delete a macro from a queue (irreversible).

Returns an acknowledgement on success.

Every trigger of a queue, ascending by id: name, actions, conditions and active flag.

Auto-paginated and capped at the configured item cap unless limit is given. Use triggers_get for one trigger by id.

One queue trigger by id — its actions, firing conditions, order and active flag.

Triggers run actions on an issue when their conditions match. The webhook-action run log is triggers_webhook_log_list.

The execution log of a trigger's HTTP-request (Webhook) action, newest first.

Each record holds the outbound request and received response for one run. Only Webhook actions produce these; a trigger with no HTTP action returns an empty list.

Create a trigger on a queue — actions that fire when an issue event matches conditions.

Required: name and actions (e.g. [{"type": "Transition", …}]); optional conditions scope when it fires. Returns the new trigger.

Edit a queue trigger; only the fields set in body are changed.

Get trigger_id from triggers_get / the queue settings. Pass version to guard against concurrent edits (optimistic locking).

One queue autoaction by id — its filter/query, actions, schedule and run stats.

An autoaction periodically applies its actions to every issue matching its filter/query. For run history use autoactions_logs_list (summaries) then autoactions_logs_get (per-issue outcomes of one run).

Run summaries for an autoaction — one record per launch with hit/success/failure counts.

Each record's id is the run id you pass to autoactions_logs_get for that run's per-issue outcomes.

The per-issue outcomes of one autoaction run — each issue touched and its result status.

Get the run_id from autoactions_logs_list. Only autoactions that auto-update issues produce these detail logs.

Create an autoaction on a queue — actions applied on a schedule to matching issues.

Required: name and actions (e.g. [{"type": "Update", …}]); scope the issues with filter or query and set the cadence via intervalMillis / calendar. CAUTION: autoactions have no delete endpoint — the action persists until its queue is deleted (it can be disabled in the UI).

Current status of an async bulk-change operation (issues_update_bulk and its kin).

status runs CREATED → COMPLETE / FAILED; totalIssues / totalCompletedIssues show progress. Poll this after a bulk trigger returns an id; once it reports FAILED, call bulk_issues_list for the per-issue errors.

The issues a bulk-change operation could NOT change, each with its per-field error.

Use after bulk_get reports a non-zero failure count to see why specific issues were rejected (e.g. an invalid resolution for the target queue/type). Successful issues are not listed here.

Links from a Tracker issue to objects in external applications (Bitbucket, etc.).

Each entry carries the link type, direction, and the external object's key plus its owning application. This is the external link list — for issue-to-issue links use links_list.

Link a Tracker issue to an object in an external application; returns the created link.

Get the application id (origin) from applications_list. Pass backlink=true to also create the mirror link in the external app.

Remove a remote (external-application) link from a Tracker issue (irreversible).

Get link_id from remotelinks_list. Returns an acknowledgement on success.

Create a personal Tracker dashboard; returns it with the id used to add widgets.

NOTE: dashboard deletion is not wrapped by ycli, so the dashboard stays on the account until removed in the UI.

Add a cycle-time widget to a Tracker dashboard; returns the created widget.

Get dashboard_id from dashboards_create.

A single Tracker entity (project, portfolio or goal) by id, with its fields block.

Pass fields to pull extra parameters into the response — keyResultItems for a goal's key results, checklistItems for a project/portfolio checklist, metricItems for its metric widgets, or summary,description,entityStatus for the basics. Use entities_search to discover ids first.

Entities of a given type that match a name substring and a filter, sorted server-side.

Returns a flat list of entities. body.input matches part of the name, body.filter is a field → value object (author, status, followers, …), body.orderBy with body.orderAsc sorts, and body.rootOnly keeps the entities with no parent.

An entity's event history (created/updated/commented/…), auto-paginated.

Each event carries an author, a timestamp, a display title and the individual field changes. Capped at the configured item cap unless limit is given.

An entity's access settings — the READ/WRITE/GRANT ACL plus inheritance sources.

acl lists the users, groups and roles granted each level; permissionSources names the parent entities this one inherits permissions from. Change them with entities_permissions_update.

An entity's direct READ / WRITE / GRANT rights — the users, groups and roles holding each.

Unlike entities_permissions_get this leaves out inheritance (permissionSources). Change the rights with entities_permissions_update_direct.

All comments on an entity — author, text, timestamps and summoned users.

A single comment on an entity by id.

An entity's links to other entities — the link type and the linked entity's summary + id.

Files attached to an entity — name, size, MIME type, uploader and download URL.

Returns metadata only. Downloading the raw bytes is CLI/SDK-only — run ycli tracker entities attachments download <FILE_ID> <FILENAME> — because binary blobs are not an MCP payload.

One attachment's metadata (name, size, MIME type, download URL).

Downloading the raw bytes is CLI/SDK-only (tracker entities attachments download).

Current status of an async entity bulk-change operation started by entities_update_bulk.

status runs CREATED → COMPLETE / FAILED; poll until it settles.

An entity's comments via the cursor-paginated …/comments/_relative endpoint.

Prefer this over entities_comments_list when the comment thread is long — it drains pages up to limit (the configured item cap by default).

Create a Tracker entity (project, portfolio or goal); returns it with its id.

Edit a Tracker entity; only the fields keys present in body are changed.

Returns the updated entity.

Permanently delete a Tracker entity (project/portfolio/goal) — irreversible.

Pass with_board=true to also delete a project's linked agile board. Returns an acknowledgement on success.

Change an entity's access rules; returns the resulting permission set.

The acl object of body accepts only grant / revoke actions, each mapping an access level (READ/WRITE/GRANT) to users/groups/roles, e.g. {"acl": {"grant": {"READ": {"users": ["8000000000000002"]}}}}. Read the current ACL first with entities_permissions_get.

Grant and revoke an entity's direct rights; the rest stay as they are.

grant and revoke each map READ / WRITE / GRANT to users (logins or ids), groups (ids) and roles (AUTHOR, OWNER, CLIENT, FOLLOWER, MEMBER). Returns the resulting rights. Read them first with entities_permissions_get_direct.

Start an async bulk field update over many entities; returns the operation.

Poll the returned operation id with entities_bulk_get.

Request a report over Tracker entities (POST /entities/report/).

Returns the report entity.

Add a comment to a Tracker entity; returns the created comment.

Edit a comment on a Tracker entity; returns the updated comment.

comment_id addresses the comment (get it from entities_comments_list).

Permanently delete one comment from a Tracker entity (irreversible).

Returns an acknowledgement on success.

Add checklist item(s) to a Tracker entity; returns the entity with its checklist.

body is a bare array of items, e.g. [{"text": "…"}].

Replace/update a Tracker entity's checklist items in one call.

body is a bare array of items, each with id/text/checked. To edit a single item by id use entities_checklists_items_update. Returns the entity with its checklist.

Edit one checklist item on a Tracker entity (text, checked state, assignee, deadline).

Returns the entity with its updated checklist.

Permanently delete the ENTIRE checklist of a Tracker entity (all items, irreversible).

To remove a single item use entities_checklists_items_delete. Returns the entity.

Permanently remove one item from a Tracker entity's checklist (irreversible).

Returns the entity with its remaining checklist.

Reorder a checklist item within a Tracker entity's checklist.

Returns the entity with its reordered checklist.

Link a Tracker entity to another entity (e.g. relates, depends on).

Returns an acknowledgement on success.

Remove the link between a Tracker entity and another entity (irreversible).

right is the id of the entity on the other end (see entities_links_list). Returns an acknowledgement on success.

Attach a previously uploaded temporary file to a Tracker entity.

Requires a temp_file_id from the Tracker temporary-upload endpoint (not wrapped by ycli — files are usually seeded via the UI). Returns the entity.

Permanently delete an attachment from a Tracker entity (irreversible).

The API answers with an empty body; returns an acknowledgement on success.

Every workflow of the organization (deleted ones excluded) with its steps and actions.

A workflow is the status graph an issue type follows. Use workflows_get for one by id and workflows_list_for_queue to see which workflow each issue type of a queue uses.

One workflow with its steps, initial action, queue binding and version.

A step is a status with the transitions leaving it; version is needed to edit the workflow.

The workflows a queue uses: a map from workflow id to the issue types that follow it.

Create a workflow; returns it with its generated id and version.

Required: name, initialAction (name and target status) and steps (each a status with its actions). Statuses are given as keys such as open and must exist; names are {"ru": …, "en": …} objects.

Edit a workflow.

Only the fields set in body change, and a given steps list replaces the whole step list. Returns the workflow with its incremented version.

Edit one action (transition) of a workflow step; only the fields set in body change.

Returns the whole workflow with its incremented version.

Delete a workflow (irreversible). Returns an acknowledgement.

Every project of the organization (the legacy Projects API).

entities_search is the newer way to find projects and portfolios.

One project: name, lead, stage, dates and version (needed to edit it).

The queues whose issues belong to a project.

Create a project (legacy Projects API).

name and queues (a queue key) are required, status is DRAFT, IN_PROGRESS, LAUNCHED or POSTPONED. Returns the project.

Edit a project; queues is required on every edit, other fields change when set.

Returns the project with its incremented version.

Delete a project (irreversible). Returns an acknowledgement.

The absences (vacation, illness, trips, duty, …) of the given users that overlap a window.

A read done via POST; needs Tracker administrator rights. Every requested user appears, with an empty gaps list when they are not absent.

Create up to 100 employee absences; needs Tracker administrator rights.

Each gap needs user, workflow (vacation, paid_day_off, illness, absence, trip, conference_trip, conference, learning, maternity or duty), from and to (ISO 8601, from earlier). Returns the absences actually saved.

Delete employee absences by id (irreversible); ids the API does not know are ignored.

Needs Tracker administrator rights. Returns an acknowledgement.

The authenticated Yandex Wiki user (a safe auth probe).

The page's markdown body for SLUG.

Page metadata for SLUG (attributes + owner).

All descendant refs under SLUG, auto-paginated.

Capped at the configured item cap unless limit is given; narrow by SLUG for large trees.

Dynamic tables (grids) attached to a page id, auto-paginated (drains next_cursor).

Each grid ref is a UUID id + title + created_at. Capped at the configured item cap unless limit is given. Reads a page's numeric id — pair with pages_get_meta / pages_descendants_list (whose refs carry the ids) to find one.

A single page by its numeric id — the id-based twin of pages_get/pages_get_meta.

Use it when you hold a numeric page id (e.g. from a descendants listing or a write's response) instead of the slug. fields follows the standard Wiki selector rules: without it the response carries id/slug/title only; ask for content or attributes explicitly.

All descendant page refs under a numeric page id, auto-paginated.

The id-based twin of pages_descendants_list. Capped at the configured item cap unless limit is given; each ref carries the child's numeric id and permanent slug.

Create a wiki page at body.slug (POST /pages).

Treat the slug as permanent: pages_move can rename the page later, but the old address then answers 404 and links to it break, so pick the slug carefully. Returns the created page (its numeric id drives the id-based tools and every subsequent write). E.g. {"body": {"slug": "data/x", "title": "X", "content": "# X"}}.

Change a wiki page by numeric id: only the fields set in body change.

body.content REPLACES the whole text — to add to an existing page use pages_append instead. The Wiki API updates via POST, not PATCH (PATCH returns 405); the SDK already handles that quirk. Repeating the same call yields the same page state (idempotent). E.g. {"page_id": 7, "body": {"title": "New name"}}.

Delete a wiki page by numeric id (DELETE /pages/{id}).

KEEP the returned recovery_token — it is the only handle to undo the delete (redeem it with recovery_recover). Deleting removes the page's descendants' anchor too, so double-check the id (pages_get_by_id) before calling.

Append a YFM fragment to a wiki page without rewriting the whole body.

Unlike pages_update (full replace), this adds body.content at the chosen spot: body.body.location (top/bottom of the page), a numbered body.section, or a named text body.anchor. Returns the updated page.

Copy a page to a new address (POST /pages/{id}/clone — asynchronous).

Cloning leaves the original where it is; to give the page itself a new slug use pages_move. The call returns a deferred operation reference — poll operations_clone_get with the returned operation.id until it reaches a terminal status.

Move or rename pages (POST /pages/move — asynchronous; undocumented by Yandex).

The only way to give a page a new slug. The call returns a deferred operation reference — poll operations_move_get with the returned operation.id until it reaches a terminal status. A page moves with its subtree and links to the old address may stop working, so try validate_only=true first: it validates the request, applies nothing, and its operation id cannot be polled. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Saved revisions of a page, auto-paginated (GET /pages/{id}/revisions).

Each revision has an id (what GET /pages takes as revision_id), its author, created_at, page_type and publication state. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Refs (id and slug) of the pages that link to a page (GET /pages/{id}/backlinks).

Auto-paginated. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Full-text search over wiki pages and files; returns one page of hits.

Each hit has the page slug (read it with pages_get), title, a content snippet, the type and modified_at. body.filters narrows the search by type, authors, cluster (a page slug), created_at / modified_at (a window with both from and to) and show_obsolete. For the next page pass next_cursor back as body.cursor; stop at the first page without hits, because next_cursor stays set after an empty page. A new page can take seconds to appear in the index. E.g. {"body": {"query": "roadmap", "limit": 5}}.

Grant a user or a group a role on a wiki page; returns the new access entry.

A user who already holds a personal access is refused: change it with access_update. Read the current accesses with pages_get_by_id and fields="access_policy,access_lists".

Change the role or reach of one access entry on a wiki page.

The page owner's own entry cannot be changed.

Revoke one access entry on a wiki page — the holder loses that grant at once.

The page owner's own entry cannot be revoked.

Revoke every personal access on a wiki page except the owner's.

Everyone but the owner falls back to the page's access policy. Irreversible: the revoked entries are not kept.

Comments on a page id, auto-paginated (drains the next_cursor internally).

Capped at the configured item cap unless limit is given. Pair with pages_get_meta (its attributes.comments_count tells you how many exist).

A comment and its replies, reconstructed from the page's comment list.

The Wiki /thread endpoint (comments_thread_get) is dead (returns no replies), so this fetches every comment on the page and chains parent_id from the target: the comment comes first, then its descendants in depth-first order. Capped at the configured item cap unless limit is given. Use comments_list first to discover a root comment id, then this to read its thread.

The thread of a comment as the Wiki server returns it — an empty list for every real thread.

Checked live on 2026-10-02: the server's /thread endpoint has no replies to give, for a root comment or a reply, plain or inline. Use comments_thread_list, which rebuilds the thread from the page's comment list.

Add a comment (or a threaded reply) to a wiki page.

Pass body.parent_id to reply to an existing comment — find ids with comments_list. Returns the created comment with its numeric id.

Delete a comment from a wiki page — irreversible (no recovery token).

Returns the page's remaining comments_count. Verify the target with comments_list / comments_thread_list first: deleting a parent orphans its replies' threading.

Attachments (name, size, mime type) on a page id, auto-paginated (drains next_cursor).

Capped at the configured item cap unless limit is given. This is the list surface; downloading an attachment's bytes is CLI/SDK-only (binary blobs are not an MCP payload).

Metadata of one attachment (GET /pages/{id}/attachments/{file_id}).

Name, size, MIME type, download URL, whether a preview exists and the virus-check status. Yandex does not document this operation (it is in the live OpenAPI only) and may change it. Fetching the bytes (download, preview) is CLI/SDK-only.

Attach file(s) from finished upload sessions to a wiki page.

The final step of the upload pipeline: create the session (uploadsessions_create), send the bytes (uploadsessions_parts_upload), close it (uploadsessions_finish), then attach here. For one small file, attachments_upload runs the whole pipeline in a single call. Returns the newly-attached files.

Upload one small file and attach it to a wiki page in a single call.

Runs the whole pipeline end to end: opens an upload session sized to data, PUTs the bytes as a single part, finishes the session, and attaches it to the page. Small-file path — for large files drive uploadsessions_create / uploadsessions_parts_upload (chunked) / uploadsessions_finish + attachments_attach yourself. Returns the newly-attached files.

Delete an attachment from a wiki page — irreversible (no recovery token).

The API answers 204 No Content; a typed acknowledgement is returned instead. Find file_id with attachments_list and double-check it before calling.

A page's resources — attachments AND grids — as {type, item} envelopes, auto-paginated.

The unified single-pass listing over what attachments_list and pages_grids_list expose separately (drains next_cursor internally). Capped at the configured item cap unless limit is given; narrow with q (title) or types (attachment,grid).

Undo a page delete: redeem a recovery_token and bring the page back.

pages_delete returns the token — it is the only handle to the deleted page. Returns the restored page's numeric id and permanent slug, and pages_count, how many pages came back (the page and those under it). No request body; the token in the path is the whole request.

A single dynamic table (grid) by its UUID, with structure, rows and revision.

Grids are the modern dynamic tables attached to a page; find a grid's id with pages_grids_list. Use row_filter/only_cols/only_rows/sort to narrow large grids server-side, and fields=attributes,user_permissions for extra blocks. The returned revision is what any subsequent write must send back.

Create an empty dynamic table (grid) as a resource of a page.

A new grid has no rows or columns — add them afterwards with grids_columns_create and grids_rows_create. Returns the created grid; every subsequent write sends its revision back.

Rename or re-sort a grid (POST-not-PATCH quirk handled by the SDK).

body.revision must match the grid's current revision (read it off grids_get); a mismatch fails the write. Returns the grid's new revision.

Delete a grid — irreversible (grids have NO recovery token, unlike pages).

Verify the target with grids_get first. The API answers 204 No Content; the result is a typed acknowledgement.

Insert rows into a grid at a position (default: append at the end).

Column slugs come from grids_get's structure block. Returns the created rows plus the grid's new revision.

Delete rows from a grid by id — irreversible.

A rare DELETE-with-body: ids and revision travel in the JSON body. Find row ids with grids_get. Returns the grid's new revision.

Reorder rows inside a grid (move a run of consecutive rows to a new position).

Returns the grid's new revision.

Add columns to a grid at a position (default: append after the last column).

Each column needs a title and a type (string, number, select, staff, date, checkbox, ticket_field, …); type-specific fields such as select_options shape it further. Returns the grid's new revision.

Delete columns from a grid by slug — irreversible (every cell in them is lost).

A rare DELETE-with-body: slugs and revision travel in the JSON body. Returns the grid's new revision.

Reorder columns inside a grid (move a run of consecutive columns to a new position).

Returns the grid's new revision.

Set the value of individual grid cells (addressed by row id + column slug).

Repeating the same call sets the same values (idempotent). Returns the updated cells plus the grid's new revision.

Copy a grid onto another page (POST /grids/{id}/clone — asynchronous).

body.with_data=true copies the rows as well as the structure. Returns a deferred operation reference — poll operations_clone_inline_grid_get with the returned operation.id until it reaches a terminal status.

Check whether a column slug is free in a grid and get free alternatives (read-only).

The call is a POST but changes nothing. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Edit a grid column in place: only the fields sent change; its type and slug stay.

Repeating the same call leaves the same column (idempotent). revision is accepted but not enforced, and every call moves the grid's revision on. Returns the grid's new revision and the column as saved. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Pin or colour one grid row (cell values are set by grids_cells_update).

Repeating the same call leaves the same row (idempotent). The reply is a bare acknowledgement without the new revision (read it with grids_get); revision is accepted but not enforced. Yandex does not document this operation (it is in the live OpenAPI only) and may change it.

Status of an async page-clone operation — poll it until it finishes.

pages clone (a CLI/SDK write) returns an operation.id; pass it here and re-read until status is success or failed. On success the result.page names the clone. The sibling operations_clone_inline_grid_get polls inline-grid clones instead.

Status of an async inline-grid-clone operation — poll it until it finishes.

grids clone (a CLI/SDK write) returns an operation.id; pass it here and re-read until status is success or failed. On success the result.grid_id names the copy. The sibling operations_clone_get polls page clones instead.

Status of an async page-move operation — poll it until it finishes.

pages_move returns an operation.id; pass it here and re-read until status is success or failed. On success the result.page_count says how many pages moved. This operation is undocumented by Yandex (it is in the live OpenAPI only) and may change.

Current state of a Wiki file upload session by its UUID (status, file name/size, storage).

Poll this to watch a session move not_started → in_progress → finished before the file is attached to a page.

Open an upload session — step 1 of the Wiki file-upload pipeline.

The returned session_id addresses the session for uploadsessions_parts_upload / uploadsessions_finish. For a single small file, attachments_upload runs the whole pipeline in one call instead.

Upload one file part to an open session — step 2 of the upload pipeline.

The base64 data is decoded and sent as raw application/octet-stream bytes. Parts may be 5-16 MB except the last; a small file fits in a single part_number=1 call. Returns the session (poll status via uploadsessions_get).

Close an upload session after its last part — step 3 of the upload pipeline.

Only a finished session can be attached to a page (attachments_attach). Returns the session with its final status.

Cancel one in-progress upload session, discarding its uploaded parts.

Frees the session's quota; the session cannot be resumed afterwards. Returns the session with status: aborted.

Cancel EVERY active upload session of the caller, discarding all uploaded parts.

A quota-freeing sweep — use it when stale sessions block new uploads; prefer uploadsessions_abort to cancel a single known session.

The authenticated Yandex Forms user (a safe auth probe).

Every form (survey) the caller can see, auto-paginated over the API's offset pages.

Capped at the configured item cap unless limit is given. Each item's id is the form id you pass to surveys_get / questions_list / answers_list.

One form's settings by id.

Create a new form from the given settings; returns the created Survey (note its id).

Only the fields you set are sent. Follow up with questions_create to add questions and surveys_publish to make the form fillable.

Patch a form's settings — only the fields set in body change; returns the Survey.

Untouched settings keep their current values, so a partial patch is safe to repeat.

Delete a form permanently — IRREVERSIBLE: its questions and collected answers are lost.

The API answers 204 No Content; the returned record confirms the accepted action.

Publish a form so respondents can fill it; fails if the form is blocked or at its cap.

The API answers a bare 200 OK; the returned record confirms the accepted action. Reverse with surveys_unpublish.

Take a published form offline (respondents can no longer fill it); reversible via publish.

The API answers a bare 200 OK; the returned record confirms the accepted action.

A form's questions, grouped into pages (the {pages} envelope).

One question's settings by id — label, slug, type and common presentation flags.

Where questions_list returns every question grouped into pages, this fetches a single question keyed by question_id (take it from an item's id in questions_list). Type-specific detail (validators, options, conditions) comes in the fields of its type.

Append a question to a form; returns the created Question (note its id).

body is one of the 12 typed question schemas discriminated by type (string, enum, matrix, …). The new question lands at the end of the form — reposition it afterwards with questions_move.

Replace a question's settings (same typed body as create); returns the updated Question.

The body's type must match the existing question's type; look it up with questions_get first.

Delete a question from a form; one that a display condition refers to is refused.

Delete the condition first (conditions_question_delete).

The API answers 204 No Content; the returned record confirms the accepted action.

Reposition a question on the form (target page + position); returns the moved question's id.

body.position needs a page target to take effect — the underlying API silently ignores a bare position (200, nothing moves) — so QuestionMove raises a validation error if position is set with no page / page_id / question / create_page target; pass one explicitly (e.g. page=1). Display-condition consistency is validated server-side — moving a question above one its conditions depend on is rejected.

A question's show conditions: the {operator, items} envelope of condition groups.

The top-level operator joins the GROUPS; each group has its own operator joining its clauses. A group's integer id is what the get/update/delete tools take.

One condition group of a question by id — its operator and clause items.

Clauses have no ids of their own: edit one by replacing the whole group via conditions_question_update.

Add a condition group to a question — it shows only when its conditions match.

The group operator joins the clauses WITHIN it; at least one clause is required. Returns the created group with its server-assigned integer id.

Replace a question's condition group — a FULL replacement, not a partial update.

Despite the PATCH verb the API validates a complete group: operator and at least one clause are both required; the group id is never sent.

Delete one condition group from a question; the other groups stay untouched.

Set the boolean operator BETWEEN a question's condition groups; returns the envelope.

Group-internal operators are untouched — change those via conditions_question_update.

A page's show conditions: the {operator, items} envelope of condition groups.

The top-level operator joins the GROUPS; each group has its own operator joining its clauses. A group's integer id is what the get/update/delete tools take.

One condition group of a page by id — its operator and clause items.

Add a condition group to a page — the page shows only when its conditions match.

Page clauses still reference QUESTION slugs (type=question + question). Returns the created group with its server-assigned integer id.

Replace a page's condition group — a FULL replacement, not a partial update.

Delete one condition group from a page; the other groups stay untouched.

Set the boolean operator BETWEEN a page's condition groups; returns the envelope.

The submit button's show conditions: the {operator, items} envelope of groups.

These hang directly on the survey (GET /surveys/{id}/conditions).

One condition group of the submit button by id — its operator and clauses.

Add a condition group gating the form's submit button; returns it with its id.

Replace a submit-button condition group — a FULL replacement, not a partial update.

Delete one condition group from the submit button; the other groups stay untouched.

Set the boolean operator BETWEEN the submit button's condition groups.

An integration group's conditions: the {operator, items} envelope of groups.

The group's integrations run on a new answer only when these conditions match.

One condition group of an integration group by id — its operator and clauses.

Add a condition group to an integration group; returns it with its id.

Replace an integration group's condition group — a FULL replacement.

Delete one condition group from an integration group; the others stay untouched.

Set the boolean operator BETWEEN an integration group's condition groups.

Who may edit (change) and who may fill (submit) a form, one entry per action.

access is owner, restricted (the listed users/groups), common (the whole organization) or public (anyone with the link).

Set the access level of one action (change or submit); returns every permission.

Let a user or a group perform an action on a form; returns every permission.

Granting someone who already has the action changes nothing.

Stop a user or a group performing an action on a form; returns every permission.

The changes made to a form — who changed which part, when — across pages.

Capped at the configured item cap unless limit is given.

One full form response by answer_id or answer_key (the API takes one of them).

A flat query-param route (GET /v1/answers) — no survey id needed. Each data item is a self-describing question record ({id, label, type, value, …}).

A form's responses, at most limit (drains pages via the next cursor).

Returns the {columns, answers, next} envelope; next is always None in the merged result.

Start an async export of a form's answers (csv/xlsx); returns the operation to poll.

An empty body exports every answer as xlsx. Poll the returned id with operations_get until the status is terminal; download the finished file with the forms answers export --wait CLI command (binary payload — not exposed over MCP).

The integration runs one answer triggered, by answer_id or answer_key (one of them).

Each entry has the run's status and the field of its type (issue_key, link, to_address, url, ...); notifications_get has the full run.

Delete one answer of a form; answers_restore brings it back.

Bring a deleted answer of a form back.

Every personal-link key set on a form, as a flat array.

A key set is a batch of single-use keys that become personal form-filling links; each item's integer id is what you pass to keysets_get. Use surveys_list to find the survey_id first. Downloading the actual keys is a binary payload — CLI/SDK-only.

One key set's settings and usage (total keys, used count, is_enabled).

Look up keyset_id via keysets_list. To download the actual keys use the forms keysets download CLI command (binary payload — not exposed over MCP).

Create a batch of single-use personal-link keys on a form; returns the created Keyset.

The API rejects a body without is_enabled, so set it explicitly alongside name and total. Download the generated keys via the forms keysets download CLI command (binary payload — not exposed over MCP).

Replace a key set's settings; returns the updated Keyset.

Despite the PATCH verb, the API validates the body as a full record: name, total and is_enabled must all be set or the request is rejected with 400. total can only grow: a number smaller than the set has now is refused.

Delete a key set — its unused keys (personal fill links) stop working.

The API answers 200 OK with no body, so a typed acknowledgement is returned.

The status of a long-running Forms operation — poll this to watch an async export finish.

Returns {id, status, message} where status is one of ok (finished, result ready), fail, wait (still running) or not_running. Take the operation_id from the id an async trigger returned (e.g. the answers_export tool or ycli forms answers export … --no-wait); re-call until status is ok or fail.

Runs of a form's integrations (one per answer and integration), across pages.

Give survey_id: without it the API answers 404 Not Found, and the other filters only narrow that form's runs. Capped at the configured item cap unless limit is given. Read one run's context, response and error with notifications_get.

One integration run with what the integration was given, answered and failed with.

The state of one integration run: pending, success, error or canceled.

Run the integration again for that answer.

A result.status of operation means it runs in the background: poll result.operation_id with operations_get.

Stop an integration run that has not finished.

A run that is already canceled or finished answers result.status skip.

Ids of a form's failed integration runs that are still shown.

Read each with notifications_get.

Check the upload/scan status and download access of already-uploaded form-filling files.

A read done via POST — nothing is mutated. Each returned item's check_status is one of check, ready, infected, error, deleted. Uploading and downloading the files themselves are binary payloads — CLI/SDK-only.

Delete a stored form-filling file, identified by its path and/or url.

At least one of path / url must identify the file. The API answers 200 OK with no useful body, so the returned record confirms the accepted action.

Copy an existing image into a form; returns the new image with its integer id.

Reference the returned id from a question's, option's or form style's image.

The form's fill-time settings — the pages/questions to fill, submit conditions, and values.

Use this to discover a form's fillable structure: pages[].items[] are the questions (each a polymorphic question schema) and their id values are the slug keys a response is posted under. Complements surveys_get (admin settings) and questions_list (authoring view). Post a response with filling_submit.

Autocomplete prompts for a suggest-type question while filling a form.

Pass the question slug (from filling_get) plus the search text; each returned item's id/text is a candidate value for the answer.

Submit a response to a published form: a REAL answer is saved unless validate_only.

body maps each question slug (discover them via filling_get) to its answer — a scalar, a string list, a {begin, end} date range, or matrix {row, column} items. Returns the success-page payload (answer_id confirms the save).

A form's integration groups, each with its conditions and integrations.

An integration group (hook) runs its active integrations on every new answer that matches its conditions; conditions_hook_* edit the conditions, subscriptions_* the integrations.

One integration group by id, with its conditions and integrations.

Create an empty integration group on a form; returns it with its integer id.

Add integrations with subscriptions_create and conditions with conditions_hook_create.

Rename an integration group or switch it on or off; only the fields set change.

Delete an integration group together with its integrations and conditions.

Every integration of an integration group (hook), each tagged by type.

Types: email, tracker, tracker_comment, wiki, jsonrpc, http, function. hooks_list returns the same integrations nested in each hook.

One integration of a hook by id, with its type-specific settings.

Add an integration to a hook; it runs on every new answer while active is true.

Create it with active: false to configure it without sending anything yet. Returns the integration with its integer id.

Change an integration: only the fields set in body change.

Delete one integration from a hook; the hook's other integrations stay.

The variable types a form's integrations can reference in their texts.

Each item names a type (e.g. form.answer_url, form.question_answer), the arguments it takes and the renderers it supports; put one into a subscription's variables to use it.

The DataLens instance the credentials reach (a safe auth probe).

One collection by id: its title, description and parent.

The collections with these ids; an id the caller cannot see is left out.

What a collection holds: collections, workbooks and entries, auto-paginated.

Start here to find a workbook: list the root, then descend. Capped at the configured item cap unless limit is given.

The collections from the root down to this one.

Whether the caller may create a collection and a workbook in the root.

Who has which role on a collection, auto-paginated.

Create a collection in another one, or in the root when no parent is given.

Change a collection's title or description; what is not given stays as it is.

Move a collection into another one, or into the root when no parent is given.

Move several collections into another one, or into the root when none is given.

All or none: if one collection already lies in the destination, the API answers 409 and moves none of them.

Delete a collection with everything it holds: nested collections, workbooks, entries.

Delete several collections with everything they hold.

Give or take away roles on a collection; the roles not named stay as they are.

One workbook by id: its title, description and collection.

The workbooks of one collection (the root by default), auto-paginated.

It does not descend into nested collections: collections_content_list shows what a collection holds. Capped at the configured item cap unless limit is given.

The workbooks with these ids; an id the caller cannot see is left out.

Who has which role on a workbook, auto-paginated.

What a workbook holds: connections, datasets, charts and dashboards, auto-paginated.

scope says the kind of each entry; its id opens it with the tools of that kind. Capped at the configured item cap unless limit is given.

Create a workbook in a collection, or in the root when no collection is given.

Change a workbook's title or description; what is not given stays as it is.

Move a workbook into a collection, or into the root when no collection is given.

Move several workbooks into a collection, or into the root when none is given.

All or none: if one workbook already lies in the destination, the API answers 409 and moves none of them.

Delete a workbook with everything it holds: connections, datasets, charts, dashboards.

Deleting a workbook that is already deleted answers 500, not 404: after a server error, read the workbook before deleting it again.

Delete several workbooks with everything they hold.

Give or take away roles on a workbook; the roles not named stay as they are.

Lock an entry (a dataset, a chart, a dashboard) for editing.

The reply holds the token of the lock and nothing else: keep it, extending and releasing the lock take it. An entry that is already locked answers 423 with who holds the lock and until when.

Hold a lock longer; the reply says when it expires now.

Release a lock; with force it releases a lock another editor holds.

An entry that is not locked answers 404.

The Spark clusters of DataLens, auto-paginated.

Experimental API, not measured: ycli follows its document. Capped at the configured item cap unless limit is given.

One Spark cluster: its settings, health and status. Experimental API, not measured.

Create a Spark cluster and return the operation that creates it.

A cluster is paid for while it runs: create one only when asked to. The operation goes on after the reply: lakehouseoperations_get with its id says how it ended. Experimental API, not measured.

Delete a Spark cluster and return the operation; lakehouseoperations_get reads it.

Experimental API, not measured.

Start a stopped Spark cluster and return the operation.

A cluster is paid for while it runs: start one only when asked to. lakehouseoperations_get says how the operation ended. Experimental API, not measured.

Stop a running Spark cluster and return the operation; lakehouseoperations_get reads it.

Experimental API, not measured.

The sizes an instance of a Spark cluster can take, auto-paginated.

Experimental API, not measured. Capped at the configured item cap unless limit is given.

One resource preset: its cores and its memory. Experimental API, not measured.

One HTML page: where it lies and its revisions.

The reply has no HTML of the page; htmlpages_preview_url_get gives a link that shows it. entries_list with the scope artifact finds the pages.

Create an HTML page; the reply has it under entry and warnings about its HTML.

Save new HTML of a page, or make one of its revisions the current one.

mode save makes a new revision and leaves the public one; publish shows it to everyone. With revId, save copies that revision as the current draft.

Delete an HTML page.

A temporary signed link that shows the page; it stops working after a while.

The users, groups and service accounts of the organization, auto-paginated.

The sub of a member is the subject id a role is given to: find it here before collections_access_bindings_update or workbooks_access_bindings_update. Capped at the configured item cap unless limit is given.

Entries across the whole organization: dashboards, charts, datasets, connections.

The API requires one of scope, scopes and ids. An entry the caller may not read comes with isLocked set and little else. Auto-paginated; capped at the configured item cap unless limit is given.

What entries use (a chart's dataset, a dataset's connection) or what uses them.

Use it before changing or deleting an entry, to see what depends on it. Auto-paginated.

What the caller may do with each entry, as a map by id.

An entry that does not exist gives error: "NOT_FOUND" under its id.

The revisions of an entry: who saved it and when. Auto-paginated.

Give an entry another name; its id and what refers to it stay.

What the caller may do with many entries, workbooks and collections, in one call.

Each of the three maps is keyed by id: an object the caller can see gives permissions, one that does not exist gives error: "NOT_FOUND".

One connection by id: its name, its kind and the settings of that kind.

The kind comes in db_type: the reply has no type, though creating one takes it.

A password or a token is never in the reply. workbooks_entries_list with the scope connection finds the connections of a workbook.

Create a connection and return its id.

Give workbook_id (or dir_path) for where it lies. The password or the token you give is stored by DataLens and never returned by connections_get. A connection to Google Sheets (gsheets) cannot be created here: the API answers that the type is not editable; it is made in the DataLens interface and then read like any other.

Change the fields given of a connection; returns an acknowledgement.

Delete a connection; the datasets built on it lose their source.

The API has no way to bring it back, and a chart that reads through it keeps naming its id (measured).

One dataset by id: its sources, their joins and its fields.

dataset.result_schema lists the fields with their guids, which datasets_data_get takes as columns. A source or a field of a kind this server does not know comes as it is.

Create a dataset in a workbook and return it with its id.

A dataset with no source and no field is valid: create it empty, then fill it with datasets_update.

Save a dataset as given: read it, change what it holds, send it back whole.

data.dataset replaces the content. Check a change first with datasets_validate. Read the dataset again after every save: content of an older revision is refused. The reply holds the content and the revisions; its id is null (measured).

Delete a dataset; the charts built on it lose their data.

The API has no way to bring it back, and a chart built on it keeps naming its id (measured).

Check a dataset, or changes to it, without saving anything.

The reply is the dataset as it would be, with code, message and dataset_errors. Give the content as last read: after a save, content of an older revision is refused.

Rows of a dataset: the columns asked for, one page per call.

Columns are named by the guid of a field, not by its title: read them with datasets_get. For the next page give offset together with sort.

The data a saved chart shows, as tables of columns and rows.

The chart runs with its saved settings. chartType says how it is built (wizard, ql, editor). A pivot table is not supported, and a chart whose source cannot be reached answers with an error. entries_list with the scope widget finds charts.

One chart built in the wizard: the datasets it reads and what it shows.

entry.data is what charts_wizard_update takes back; isFavorite and permissions come only when asked for. entries_list with the scope widget finds charts; its type says how a chart is built.

Create a chart of the wizard in a workbook and return it with its id.

The entry.data of a chart read with charts_wizard_get is a valid data.

Save a chart of the wizard as given: read it, change it, send it back whole.

DataLens does not check a revision here: a save overwrites what was saved since you read it (measured).

Delete a chart; the dashboards that show it lose it.

The API has no way to bring it back, and a dashboard that shows it keeps naming its id (measured).

One QL chart. Unlike a chart of the wizard it comes flat, with no entry around it.

Create a QL chart; the reply is what DataLens answers, as it came.

The specification describes neither the content of a QL chart nor the reply.

Save a QL chart as given; the reply is what DataLens answers, as it came.

DataLens does not check a revision here: a save overwrites what was saved since you read it (measured).

Delete a chart; the dashboards that show it lose it.

One chart written in the editor: its kind (entry.type) and its tabs of code.

Create a chart of the editor and return it with its id.

Save a chart of the editor as given.

DataLens does not check a revision here: a save overwrites what was saved since you read it (measured).

Delete a chart; the dashboards that show it lose it.

One dashboard: its tabs and the charts, selectors and texts on them.

A real dashboard is large, 100 KB and more, which may be over what a client shows of a tool's reply: read a big one as a file (ycli datalens dashboards get <id> > dash.json). entry.data is what dashboards_update takes back.

Create a dashboard and return it with its id.

data needs counter, salt, settings and tabs; a tab may be empty. entry.meta must be an object, {} when empty: without it DataLens answers 400 entry.meta: expected record, received undefined.

Save a dashboard as given: read it, change data, send it back whole.

DataLens does not check a revision here: a save overwrites what was saved since you read it (measured).

Delete a dashboard.

One report: its slides and the charts and texts on them.

entry.data and entry.meta are what reports_update takes back. entries_list with the scope report finds reports. A report has no branch in the API: the read answers the saved version (measured).

Create a report in a workbook; the API keeps no layout of slide elements.

Measured (2026-10-06): a report made through the API loses the layout of the elements of its slides and part of its settings, so a copy of a report read with reports_get loses where its elements stood. Say so before making one. DataLens refuses a report with no slide: data.slides holds at least one.

Save a report; it LOSES the layout of its slide elements and some settings.

DataLens does not check a revision here: a save overwrites what was saved since you read it (measured).

Measured (2026-10-06): DataLens drops them on a save through the API, without a word, though every value is sent. Ask the person before saving an existing report. Otherwise: read it, change data, send it back whole.

Delete a report.

Start exporting a workbook and return the id of the export.

The export runs on its own: ask workbookexports_status_get until status is success, then workbookexports_result_get for the document.

How far an export is: pending, success or error, and the progress in percent.

notifications holds what the export has to say about an entry: id, level, message.

The exported workbook: every entry it holds, as one document.

data is what workbookimports_start takes. An export that is not over, or was cancelled, answers 409 Conflict. The document is large (hundreds of kilobytes for a workbook with a dashboard) and holds no password or token of a connection.

Stop an export: its status becomes error, with WORKBOOK_EXPORT_CANCELLED.

An export that is over stays as it ended, and the call answers the same.

Start making a workbook from an export; returns the ids of the import and the workbook.

The workbook exists at once and is filled as the import runs: ask workbookimports_status_get until status is success. Its connections come without their secrets (a notification …CONN.CHECK_CREDENTIALS says so): give each its password or token again with connections_update.

How far an import is: pending, success or error, and the progress in percent.

notifications holds what the import has to say about an entry: id, level, message.

The embeds of one entry: where a chart or a dashboard is shown on another site.

Embed an entry and return the embed.

The key for embedding is one of the workbook the entry lies in (embeddingsecrets_list).

Save an embed as given and return it.

The embed is replaced whole: read it with embeds_list and send back what is to stay; a list left out is saved empty.

Delete an embed; its links stop working. Deleting again answers 404.

One key for embedding: its name, its workbook, who made it. Never its private key.

The keys for embedding of a workbook, without their private keys.

Make a key for embedding and return its id and its private key.

The private key is given once: embeddingsecrets_get and embeddingsecrets_list do not return it. It comes in this tool's result, so it enters your context: hand it to the person at once, and do not repeat it in later messages.

Delete a key for embedding. Deleting again answers 404.

Who has which role on a shared entry, auto-paginated.

An entry that lies in a workbook, or an id nothing knows, answers an empty list.

Give or take away roles on a shared entry; the roles not named stay as they are.

The roles are datalens.sharedEntries.* (viewer, admin, …).

The entries changed in a period, auto-paginated: what, when and by whom.

A deleted entry is listed too, with isDeleted.

What one user may do with each entry: execute, read, edit, admin, by entry id.

One saved SQL query: its text, its connection and its parameters.

Experimental in the DataLens API and written from its document: not measured. An organization whose SQL editor is off answers 403 SQL_EDITOR_NOT_ALLOWED.

Save a SQL query in a workbook and return it.

Experimental in the DataLens API and written from its document: not measured. An organization whose SQL editor is off answers 403 SQL_EDITOR_NOT_ALLOWED.

Save a SQL query anew and return it; the connection and the text go every time.

Experimental in the DataLens API and written from its document: not measured.

Delete a saved SQL query.

Experimental in the DataLens API and written from its document: not measured.

Run a saved SQL query on its connection and return the result of each statement.

The text runs as it is saved: one that changes data changes it. Experimental in the DataLens API and written from its document: not measured.

The licences (seats) of the DataLens instance, auto-paginated.

Each says whose it is, its type (creator or viewer), whether it is active, and when its holder last signed in.

Give each of these users a licence and return the licences given.

A licence is a seat DataLens bills for: ask the person before calling. Written from the DataLens document and never called: not measured.

How many licences the instance may hold: the limit in force and the one that takes over.

current carries the count of active licences; next is null when no change is set.

Set how many licences the instance may hold and return the limits.

The limit is the number of seats DataLens bills for: ask the person before calling. Written from the DataLens document and never called: not measured.

The cloud environments of the DataLens instance, auto-paginated.

Experimental in the DataLens API. An instance with none answers an empty list.

One cloud environment: its cloud, its subnet, its status and its storage.

Experimental in the DataLens API and written from its document: not measured. An id nothing knows answers 403 Permission denied, not 404: it is not a lack of rights.

Make a cloud environment and return the operation that makes it.

It creates resources in a cloud, which may be billed: ask the person before calling. Experimental in the DataLens API, written from its document and never called: not measured.

Change the fields given of a cloud environment and return the operation.

Experimental in the DataLens API, written from its document and never called: not measured.

Delete a cloud environment and return the operation that deletes it.

Experimental in the DataLens API, written from its document and never called: not measured.

The paths of the objects in a cloud environment's storage bucket, auto-paginated.

Experimental in the DataLens API and written from its document: not measured. An environment nothing knows answers 403 Permission denied, not 404: it is not a lack of rights.

The size of an object, in bytes as a string, and when it last changed.

Experimental in the DataLens API and written from its document: not measured. An environment nothing knows answers 403 Permission denied, not 404.

A signed link to read one object of the bucket.

The link works for whoever holds it, for a time, and it comes in this tool's result: hand it to the person and do not repeat it. Experimental in the DataLens API and written from its document: not measured.

A signed link to put one object into the bucket.

The link works for whoever holds it, for a time, and it comes in this tool's result: hand it to the person and do not repeat it. Experimental in the DataLens API and written from its document: not measured.

The REST catalogs of the DataLens instance, auto-paginated.

Experimental in the DataLens API. An instance with none answers an empty list.

Make a REST catalog and return the operation that makes it.

It creates a bucket in a cloud, which may be billed: ask the person before calling. Ask lakehouseoperations_get for the operation until done. Experimental in the DataLens API, written from its document and never called: not measured.

How far an operation is: done or not, and then its error or its response.

Experimental in the DataLens API and written from its document: not measured. An id nothing knows answers 403 Permission denied, not 404: it is not a lack of rights.

The Trino clusters of the DataLens instance, auto-paginated.

Experimental in the DataLens API. An instance with none answers an empty list.

One Trino cluster: its configuration, its health, its status and its coordinator.

Experimental in the DataLens API and written from its document: not measured. An id nothing knows answers 403 Permission denied, not 404: it is not a lack of rights.

Make a Trino cluster and return the operation that makes it.

A cluster is cloud resources, billed while it runs: ask the person before calling. Experimental in the DataLens API, written from its document and never called: not measured.

Delete a Trino cluster and return the operation that deletes it.

Experimental in the DataLens API, written from its document and never called: not measured.

Start a stopped Trino cluster and return the operation that starts it.

A running cluster is billed: ask the person before calling. Experimental in the DataLens API, written from its document and never called: not measured.

Stop a running Trino cluster and return the operation that stops it.

Experimental in the DataLens API, written from its document and never called: not measured.

Attach a REST catalog to a Trino cluster and return the operation.

Experimental in the DataLens API, written from its document and never called: not measured.

Detach a REST catalog from a Trino cluster; the catalog itself stays.

Experimental in the DataLens API, written from its document and never called: not measured.

The sizes a cluster's machines may have in a cloud environment, auto-paginated.

Experimental in the DataLens API and written from its document: not measured. An environment nothing knows answers 403 Permission denied, not 404.

One size of a cluster's machines: its cores and its memory.

Experimental in the DataLens API and written from its document: not measured.

The applications of a Spark cluster, auto-paginated.

Experimental in the DataLens API and written from its document: not measured. A cluster nothing knows answers 403 Permission denied, not 404: it is not a lack of rights.

One Spark application: its status, its times and what it runs.

Experimental in the DataLens API and written from its document: not measured. An id nothing knows answers 403 Permission denied, not 404.

Make a Spark application on a cluster and return the operation that makes it.

Experimental in the DataLens API, written from its document and never called: not measured. Ask the person before calling.

Stop a Spark application and return the operation that cancels it.

Experimental in the DataLens API, written from its document and never called: not measured.

One fragment of an application's log, and the token of the next one.

Give nextPageToken back as page_token to read on. Experimental in the DataLens API and written from its document: not measured.

Report whose token this is, its organization and which services accept it.

credential says which token is in use (oauth or iam), never its value. identity is the token's owner (Yandex ID; unknown for an IAM token). organization is the configured id and, when the token has the directory:read_organization scope (API 360), its name. services has one probe each, with valid and, on failure, detail.

Read one definition of a body that its tool lists as a free-form object.

Such a parameter says in its description which definition to start from. The answer refers to others as #/$defs/<name>: read those with this tool too, only the ones the task needs.