# Object IDs and AI agents (/docs/integrations/object-ids)



Every widget, page, report, node, knowledge-base page and skill in Ovidens - and every indicator,
dimension, group, consistency check, reporting period, collection round and survey question - has
an ID of its own, such as `wdg_k3m9x2qd7f`. Instead of describing where something is ("the Sales
app, the fourth page, the table called Open orders"), copy its ID and give it to your AI. The AI
reads exactly that object, in one step, without searching for it.

This works with any AI you have connected to your workspace - Claude, ChatGPT or another AI that
speaks MCP (see [Connect your own AI](./mcp.mdx)) - and with
[Vera](../tips/interact-with-vera.mdx) in an analytic app.

## What an ID looks like [#what-an-id-looks-like]

An ID starts with a few letters that say what kind of object it is, then an underscore and ten
letters and digits. It has no spaces and no hyphens, so a double-click selects all of it.

| Starts with | Object                          | Starts with | Object              |
| ----------- | ------------------------------- | ----------- | ------------------- |
| `app_`      | an app                          | `ind_`      | an indicator        |
| `page_`     | a page of a Visualisation       | `dim_`      | a dimension         |
| `wdg_`      | a widget                        | `grp_`      | an indicator group  |
| `rpt_`      | a report                        | `chk_`      | a consistency check |
| `node_`     | a pipeline node                 | `per_`      | a reporting period  |
| `kb_`       | a knowledge-base page or folder | `rnd_`      | a collection round  |
| `skl_`      | a skill                         | `qst_`      | a survey question   |

## Where to copy an ID [#where-to-copy-an-id]

* **A widget:** hover over the widget - in the app and in the editor - and a small ID icon
  appears right after its title. Click it to copy the ID. On a touch screen the icon is always
  shown.
* **A page or a report:** hover over its row in the app's sidebar. The ID icon appears among the
  row's other actions.
* **The app:** on the apps list, hover over the app and click **Edit app** (the pencil). The dialog
  shows an **App ID** row under the Technical ID, with its own copy button. This works for every
  app type. In an analytic app, the ID icon also sits next to the app's name in the header.
* **A knowledge-base page:** open the row's menu in the knowledge-base tree and choose
  **Copy ID**. An open page, and an open report, also show the ID icon next to their name.
* **Everything else** - a node, a skill, an indicator, a dimension, a group, a consistency check, a
  reporting period, a collection round and a survey question: its panel shows an ID row under the
  Technical ID (a group, which has no Technical ID, shows it under its name). The row is labelled
  with the kind, such as **Node ID** or **Question ID**, and has its own copy button.

An object gets its ID the moment it is saved. A reporting period that only exists in the timeline -
nobody has renamed it, handed it over for review, approved it or started a round in it - gets its ID
once it is saved for one of those reasons.

**Copy link** in the app header's menu and in the knowledge-base row menu copies a link instead. The
link opens the object in Ovidens, and your AI accepts it just like an ID, because every link Ovidens
copies carries the object's ID.

## Hand an ID to your AI [#hand-an-id-to-your-ai]

Paste the ID into your AI with the word `fetch` in front of it:

```
fetch wdg_k3m9x2qd7f
```

Or use it in a question - "what does wdg\_k3m9x2qd7f show for March?" - or paste a copied link. A
connected AI hands the ID to Ovidens' **fetch** tool and gets the object back.

Two optional additions change what it reads:

| Add               | What it does                                                            | Example                          |
| ----------------- | ----------------------------------------------------------------------- | -------------------------------- |
| `@published`      | Read the published version's setup instead of your open draft.          | `fetch wdg_k3m9x2qd7f@published` |
| `@draft`          | Read the open draft. With no draft open, your AI is told there is none. | `fetch page_x2kq7m1c0d@draft`    |
| `:p2`, `:p3`, ... | Read the next page of a long answer.                                    | `fetch node_7m1c0dx2kq:p2`       |

A version and a page can be combined: `fetch wdg_k3m9x2qd7f@published:p2`.

## What your AI gets back [#what-your-ai-gets-back]

* **The object's name and a link** that opens it in Ovidens. A widget's link opens its page,
  scrolls to the widget and highlights it for a moment.
* **How it is set up** - a widget's type, the node it reads, its columns and filters; a node's
  configuration and columns; a skill's instructions; a question's text and options.
* **What it shows, as the app shows it** - a table widget's rows with its filters, visible columns,
  grouping and totals applied; a chart's series; a pivot's cells; a Figure widget's value; the
  choices a Parameters widget offers; an SQL widget's result; a node's rows; a knowledge-base
  page's text; an indicator's collected values; a dimension's members. An AI widget answers with
  the skill it runs, and reading it never runs the skill.
* **The IDs of related objects** - the app, the page a widget sits on, the node it reads, the pages
  of an app - so your AI can fetch those next.
* **Where each part came from** - which version the setup was read from, and which calculation the
  data came from.

### Which version your AI sees [#which-version-your-ai-sees]

Your AI sees what the app would show you: the setup from your open draft if there is one, otherwise
from the published version, and the data from the latest successful calculation of the published
version. So a widget you have just added to a draft comes back with its setup and a note that there
is no published data for it yet. Add `@published` to read exactly what everyone else sees today.

### Long answers [#long-answers]

One answer holds up to 100 rows. When there are more, the answer says so and names the ID of the
next page - for example `wdg_k3m9x2qd7f:p2` - which your AI can fetch next. A long knowledge-base
page is split into pages the same way.

## IDs stay with the object [#ids-stay-with-the-object]

* **An ID never changes while the object exists.** Renaming it, moving a widget to another page,
  publishing, opening a new draft and restoring an older version all keep it.
* **A copy of an app gets new IDs.** Importing an app, installing one from the
  [Marketplace](../marketplace.mdx), duplicating a survey and the sample apps all create objects with
  IDs of their own, so an ID always points at one object in one app.
* **A deleted object's ID stops working.** Your AI is told the object was deleted - or, if you
  removed it in your open draft, that it is still published.
* **IDs belong to your workspace.** An ID copied in another workspace is not found in yours.

## Good to know [#good-to-know]

* Your AI reads by ID with your permissions and only reads - it changes nothing. An admin allows it
  with **Fetch an object by ID** in the **Read** group of the member's **AI permissions**. If your AI
  could already read an app's Visualisation configuration, it can fetch by ID too.
* Archived apps and the Audit Analytics app are not available to AI agents; their IDs are not found.
* Reading data by ID counts toward your workspace's compute credits, like any other question your
  AI asks of the data.
