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.

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.

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

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

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.

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.

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.

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.

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

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

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

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.

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 an HTML page; the reply has it under entry and warnings about its HTML.

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.

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.

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.

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

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.

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.

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

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.

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.

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

Granting someone who already has the action changes nothing.

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

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

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

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

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

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

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.

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.

Bring a deleted answer of a form back.

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.

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.

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.

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.

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.

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

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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

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.

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.

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

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

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

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 Tracker user (a safe auth probe).

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.