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

# Verifiable identifiers (DIDs)

> Every asset, dataset, person, and project gets a citable, cryptographically verifiable DID — a persistent name you can resolve and verify, beside the internal ID.

Dataerai gives each asset, dataset, person, and project a **DID** (decentralized
identifier): a citable, persistent name that anyone can **resolve** and
**verify** cryptographically. It proves who created a thing, when, and that its
metadata and content have not changed since a given moment — without anyone
having to trust your word for it.

A DID is **minted automatically** the moment a record is created — you don't
request one. Every asset has a DID from the start; datasets, people, and
projects get one too.

The DID sits **beside** the asset's internal ID. The internal ID is an opaque
key that never leaves the system; the DID is the identifier you cite, share, and
verify.

## What a DID looks like

A DID is a short, self-describing string:

```
did:dataerai:asset:3diwgu3fawq4tkvyxuvhpeikm2wrgols
        │     │     └─ a one-way identifier, unique to this record
        │     └─ the kind: asset, dataset, person, or project
        └─ the Dataerai method
```

The last segment is a **one-way** identifier — it is derived from the record so
the DID is stable and unique, but it never reveals the internal ID.

On non-production deployments the DID carries an extra environment segment after
the method — for example `did:dataerai:beta:asset:…` — so a DID from a test
environment is visibly and cryptographically distinct from a production one.

## Two identifiers, two jobs

| Identifier      | What it's for                                                             | Visible                              |
| --------------- | ------------------------------------------------------------------------- | ------------------------------------ |
| **Internal ID** | The system's own key for the record. Used in URLs and the API.            | Inside Dataerai only                 |
| **DID**         | The citable, verifiable name. Use it in papers, datasets, and references. | Anywhere — resolvable and verifiable |

## Where you see it

Open any asset and find the **DID** row in the **General** tab of the record
sidebar. Hover over the row to reveal a **copy** button — to drop the DID into a
citation or an API call — and a **View DID document** button. **View DID
document** opens the identity's `did:web` document in a modal: for a
[published](/identity/publish-and-cite) DID it shows the live document with its
keys, status, and a **Verified** badge, plus an **Open did.json** link to the
canonical web document; for a private one you (and anyone it's shared with) get a
**preview** of the same document, marked **"Preview · not published yet."** You
can copy the document's JSON straight from the modal.

<Frame caption="Every asset gets a DID, shown on its General tab with copy and **View DID document** controls.">
  <img src="https://mintcdn.com/dataerai/JYQfiA1164D5XDuO/images/asset-overview-did.png?fit=max&auto=format&n=JYQfiA1164D5XDuO&q=85&s=c637f74c7c439f074ea8bcbf12d4d140" alt="An asset's General tab showing its DID" width="2560" height="1684" data-path="images/asset-overview-did.png" />
</Frame>

<Frame caption="The **View DID document** modal shows the document a record will publish — here as a preview, before publishing.">
  <img src="https://mintcdn.com/dataerai/JYQfiA1164D5XDuO/images/identity-did-document.png?fit=max&auto=format&n=JYQfiA1164D5XDuO&q=85&s=50c665b4d43cc55b3e9bb52fd08a0dc4" alt="The DID document modal in preview" width="2560" height="1684" data-path="images/identity-did-document.png" />
</Frame>

Dataset, person, and project identities use the same DID model. They appear
wherever that record is shown — a dataset or person on its
[profile](/discover/person-detail), and a **project** on the **Overview** of its
sidebar — and resolve and verify exactly like an asset DID. A project's DID is
the citable reference you share for the project, shown in place of its internal
ID.

## What makes it verifiable

Every DID is **signed** with an Ed25519 key — Dataerai is the trust root — and
each identity event is recorded in a **tamper-evident transparency log**, in the
style of Certificate Transparency. There is **no blockchain**.

That combination means anyone can confirm, offline and without logging in:

* the record was signed by Dataerai (the signature checks out against the
  published keys), and
* the record genuinely appears in the log at the position it claims (an
  **inclusion proof** against a signed snapshot of the log).

<Note>
  A DID is **private by default** — a new record has no public surface until you
  [publish it](/identity/publish-and-cite). Verification still works the moment a
  record exists; publishing is what makes the DID citable to the outside world.
</Note>

## DIDs are durable

A DID doesn't disappear when a record does. Deleting a record **tombstones** its
DID — it still resolves, now marked as tombstoned — so existing citations don't
break. When two person records are merged, the merged-away DID is **superseded**
and points to the surviving one. See
[Publish & cite](/identity/publish-and-cite#tombstones-and-supersedes) for the
detail.

## Next steps

<CardGroup cols={2}>
  <Card title="Resolve & verify" icon="badge-check" href="/identity/verify">
    Resolve a DID and check its signature and inclusion proof.
  </Card>

  <Card title="Publish & cite" icon="globe" href="/identity/publish-and-cite">
    Make a DID public, get its `did:web` document, and cite it.
  </Card>
</CardGroup>