Yandex 360 (ycli)

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.

Permanently delete one attachment from a Tracker issue (irreversible). Get ``file_id`` from ``attachments_list``. Returns an acknowledgement on success.

One attachment's metadata (name, size, MIME type, uploader, download URL). Downloading the bytes is CLI/SDK-only: ``ycli tracker attachments download``.

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.

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.

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.

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.

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).

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).

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.

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.

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``.

Permanently delete an agile board (irreversible; its issues are not affected). Returns an acknowledgement on success.

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.

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.

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.

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.

Every issue of a bulk change with how it went: its ``status`` and, when it failed, why. One record per issue, the ones that went well too (``COMPLETED``, measured). Use after ``bulk_get`` reports a failure to see which issues were rejected and why (e.g. an invalid resolution for the target queue/type): those carry ``error``.

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 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. A chart of the editor with no source did not answer within the client's wait: the call ends with a timeout after about two minutes (measured, twice). ``entries_list`` with the scope ``widget`` finds charts.

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

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.

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).

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.

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

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

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).

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``.

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). The interface lists what was deleted under Service settings, Deleted objects, with a Restore button (measured: the entry appears there; restoring was not tried).

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.

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).

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

Add an item to a Tracker issue's checklist (creates the checklist if absent). Returns the issue with its full 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.

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``.

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.

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.

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.

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.

The cloud environments of the DataLens instance, auto-paginated. Experimental in the DataLens API. An instance with none answers an empty list.

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.

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.

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.

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.

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.

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

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

The collections from the root down to this one.

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.

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

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

Delete several collections with everything they hold.

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

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

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.

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

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

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.

Permanently remove a column from an agile board (irreversible). Returns an acknowledgement on success.

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.

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.

Edit a board column; only the fields set in ``body`` are changed. Get ``column_id`` from ``columns_list``. Returns the updated column.

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

Permanently delete one comment from a Tracker issue (irreversible). Get ``comment_id`` from ``comments_list``. Returns an acknowledgement on success.

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

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

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.

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.

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.

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.

Replace the text of an existing comment on a Tracker issue. Get ``comment_id`` from ``comments_list``. Returns the updated comment.

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``.

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

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

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

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.

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

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).

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

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

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

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

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.

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

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

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``.

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

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

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.

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

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

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``.

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

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``.

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.

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.

Set the boolean operator BETWEEN a question's condition groups; returns the envelope. Group-internal operators are untouched — change those via ``conditions_question_update``.

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

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

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

The submit button's show conditions: the ``{operator, items}`` envelope of groups. These hang directly on the survey (``GET /surveys/{id}/conditions``).

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

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

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.

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). The interface lists what was deleted under Service settings, Deleted objects, with a Restore button (measured: the entry appears there; restoring was not tried).

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.

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

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``.

Delete a dashboard.

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.

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).

Add a cycle-time widget to a Tracker dashboard; returns the created widget. Get ``dashboard_id`` from ``dashboards_create``.

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``.

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``.

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). The interface lists what was deleted under Service settings, Deleted objects, with a Restore button (measured: the entry appears there; restoring was not tried).

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.

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).

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.

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.

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.

Embed an entry and return the embed. The key for embedding is one of the workbook the entry lies in (``embeddingsecrets_list``).

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

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

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.

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.

One attachment's metadata (name, size, MIME type, download URL). Downloading the raw bytes is CLI/SDK-only (``tracker entities attachments download``).

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.

Current status of an async entity bulk-change operation started by ``entities_update_bulk``. ``status`` runs ``CREATED`` → ``COMPLETE`` / ``FAILED``; poll until it settles.

Add checklist item(s) to a Tracker entity; returns the entity with its checklist. ``body`` is a bare array of items, e.g. ``[{"text": "…"}]``.

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.

Edit one checklist item on a Tracker entity (text, checked state, assignee, deadline). Returns the entity with its updated checklist.

Reorder a checklist item within a Tracker entity's checklist. Returns the entity with its reordered checklist.

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.

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

Permanently delete one comment from a Tracker entity (irreversible). Returns an acknowledgement on success.

A single comment on an entity by id.

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

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).

Edit a comment on a Tracker entity; returns the updated comment. ``comment_id`` addresses the comment (get it from ``entities_comments_list``).

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

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.

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.

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.

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.

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

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``.

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``.

Request a report over Tracker entities (``POST /entities/report/``). Returns the report entity.

Entities of a given type that match a name substring and a filter, sorted server-side. Returns the entities, and whether there are more. ``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.

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

Start an async bulk field update over many entities; returns the operation. Poll the returned operation id with ``entities_bulk_get``.

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 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.

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.

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

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

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.

Release a lock; with ``force`` it releases a lock another editor holds. An entry that is not locked answers 404.

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

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).

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). A name is unique among the fields: one that is taken answers 422 (measured).

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.

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.

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.

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.

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.

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``.

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).

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.

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``.

Permanently delete a saved issue filter (irreversible). Returns an acknowledgement on success.

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.

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.

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 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.

Read one definition: of a body its tool lists as a free-form object, or of a reply. A body: give ``service`` and ``name``; such a parameter says in its description which definition to start from. A reply, to know what a tool answers before calling it: give ``tool``, then ``tool`` and ``name`` for a part. The answer refers to others as ``#/$defs/<name>``: read those with this tool too, only the ones the task needs.

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.

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``.

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.

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.

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.

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.

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``.

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.

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``.

The changes made to a form — who changed which part, when — across pages. Capped at the configured item cap unless ``limit`` is given.

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``.

Delete an integration group together with its integrations and conditions.

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

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.

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

Create an HTML page; the reply has it under ``entry`` and ``warnings`` about its HTML. Creating publishes: the page is saved and published at once. A draft comes with the first ``htmlpages_update`` with ``mode="save"``.

Delete an HTML page.

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.

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

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.

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``.

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"}}}``.

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

A single Tracker issue by key.

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

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``.

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.

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

Release the scroll of an issue search before it expires (harmless housekeeping). Only a search by a scroll (`scroll_type`) has something to release; after this its `next` goes on nowhere. Returns an acknowledgement on success.

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; ``truncated`` says more may match, and ``next`` goes on. A token of a scroll (``scroll_type``) works once: used again, it gives the portion after. E.g. ``{"body": {"query": "Queue: QUEUE Status: open"}}`` or ``{"body": {"filter": {"queue": "QUEUE", "assignee": "ann"}}}``.

Typeahead over visible issues — issues whose summary contains ``text``. A lightweight title match; for full TQL search use ``issues_search``.

Start an async bulk status transition over many Tracker issues; returns the operation. Poll with ``bulk_get``.

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.

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``.

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.

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

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).

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).

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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``.

Edit a queue-local field; only the fields set in ``body`` are changed. Get ``field_key`` from ``localfields_list``. Returns the updated field definition.

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.

Permanently delete a macro from a queue (irreversible). Returns an acknowledgement on success.

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.

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.

Edit a queue macro; only the fields set in ``body`` are changed. Get ``macro_id`` from ``macros_list``. Returns the updated macro.

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

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.

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``.

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

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``.

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``.

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

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.

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``.

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.

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.

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.

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.

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"}}``.

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.

All descendant refs under SLUG, auto-paginated. Capped at the configured item cap unless ``limit`` is given; narrow by SLUG for large trees.

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``.

The page's markdown body for SLUG.

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.

Page metadata for SLUG (attributes + owner).

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.

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.

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. `…

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"}}``.

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"``.

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.

All available issue priorities in the organisation.

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).

Create a project (legacy Projects API). ``name`` is required, ``status`` is DRAFT, IN_PROGRESS, LAUNCHED or POSTPONED. The service accepts ``queues`` (a queue key) and binds no queue. Returns the project.

Delete a project (irreversible). Returns an acknowledgement.

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

Every project of the organization (the legacy Projects API). ``entities_search`` is the newer way to find projects and portfolios.

The queues whose issues belong to a project.

Edit a project; ``queues`` is required on every edit, other fields change when set. Returns the project with its incremented version.

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``.

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.

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.

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

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.

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.

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.

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.

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.

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

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).

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.

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

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.

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``.

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``.

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.

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

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

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``.

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

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.

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.

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``.

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.

Delete a report.

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).

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.

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.

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.

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).

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``).

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.

The REST catalogs of the DataLens instance, auto-paginated. Experimental in the DataLens API. An instance with none answers an empty list.

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``, …).

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.

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.

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.

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 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.

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.

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

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 resource preset: its cores and its memory. 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.

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.

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.

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.

Permanently delete a sprint (irreversible; its issues are not affected). Returns an acknowledgement on success.

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.

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.

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.

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.

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``.

Delete a saved SQL query. Experimental in the DataLens API and written from its document: not measured.

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``.

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.

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.

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``).

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.

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).

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``.

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

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

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.

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

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.

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.

One form's settings by id.

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``.

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.

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.

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

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.

Available workflow transitions for a Tracker issue.

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.

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``.

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.

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).

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.

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.

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.

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.

The Trino clusters of the DataLens instance, auto-paginated. Experimental in the DataLens API. An instance with none answers an empty list.

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 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.

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.

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.

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.

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``.

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.

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``).

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.

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.

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.

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.

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.

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.

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

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

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

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.

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.

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.

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.

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

Edit one action (transition) of a workflow step; only the fields set in ``body`` change. Returns the whole workflow with its incremented version.

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.

Delete a workflow (irreversible). Returns an acknowledgement.

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.

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.

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

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.

Log spent time on a Tracker issue; returns the created worklog 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.

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 via ``GET /worklog`` query filters (author, creation time). A lighter sibling of ``worklog_search``; every filter is optional.

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"}}}``.

Edit a worklog record on a Tracker issue (duration and/or comment). Get ``record_id`` from ``worklog_list``. Returns the updated record.