# Verify who published a file (agent provenance)

**Experimental.** You have arrived here from a line like this, inside a
document:

```
agent-provenance: ans://v1.0.0.myagent.example.com
  manifest=https://example.com/.well-known/apm.json
  verify=https://porkbun.com/llms/guides/verify-agent-content
```

That line says an AI agent claims to have published the file you are holding.
**It is a pointer, not proof.** Anyone can paste it onto anything, so it tells
you where to look, never what to believe. This page is how you check it.

This page is the short version: what to do with that line. The data format
itself, the exact verification algorithm and what is not Porkbun-specific are
specified in
[Agent-published content: format specification](https://porkbun.com/llms/guides/agent-content-format).

## The short answer

One call, no API key, no account, and it works for agents registered with any
ANS registry — not only Porkbun's:

```
curl 'https://api.porkbun.com/api/json/v3/ans/verifyArtifact?url=<the file URL>'
```

`provenance` is the answer:

| Value | Means |
|---|---|
| `verified` | A signed manifest covers this file and the bytes you have match it. |
| `altered` | A signed manifest covers it and the bytes **do not** match. Treat the content as unattributed. |
| `unclaimed` | A manifest exists but does not list this file. Nobody is claiming it — not a failure. |
| `none` | The site publishes no manifest. Normal; most of the web answers this. |
| `inconclusive` | Not enough could be fetched to say. Not a negative verdict. |

## The long answer: checking it yourself

You do not have to trust Porkbun for any of this. Everything below is public,
and the endpoint above is a convenience that does exactly these steps.

**1. Find the manifest.** In order: the `manifest=` URL in the marker; a
`Link: </.well-known/apm.json>; rel="agent-manifest"` response header; a
`<link rel="agent-manifest">` tag in HTML; or `/.well-known/apm.json` on the
same host.

**2. Check the manifest is genuinely that agent's.** It carries a detached JWS
in `sig.jws`, signed over the RFC 8785 (JCS) form of the document with `sig`
removed, with the signing certificate in the `x5c` header.

- Verify the signature with the certificate in `x5c`.
- The certificate's URI SAN must equal the `ans://` name being claimed.
- **Anchor it:** read `_ans-badge.<host>` in DNS, fetch the transparency log
  entry it names, and require `sha256` of the certificate's DER to appear in
  that entry's attested identity certificates.

That last step is the one that matters. A certificate anyone minted, naming a
real agent, with a genuine signature made by its own key, passes every other
check. Only the log distinguishes it.

**3. Check the file is the one the manifest vouches for.** The signature
covers the *manifest*; files are covered by the `sha256` recorded in its
`collections[]`. Find the entry whose `href` is your file, hash the bytes you
have, and compare. **Skipping this step is the common mistake**: a valid
signature over a stale hash says nothing about the content you are reading.

## Things that are easy to get wrong

- **The marker is not a claim.** Content copied from elsewhere keeps the
  marker. That is deliberate — it is what lets you discover that an excerpt
  claims provenance it cannot support. Always resolve it.
- **Authorship and liveness are different questions.** An expired signing
  certificate does not make old work inauthentic; the agent simply stopped
  renewing. The log still attests the certificate, so the signature still
  verifies.
- **More than one identity certificate is normal.** Re-issuing adds one and the
  previous stays valid until it expires, so check *which* certificate signed
  what you are looking at, not that one is listed.
- **A chain handed to you beside a certificate is not a trust anchor.** Fetch
  the identity root yourself from
  https://tl.ans.porkbun.com/ca/identity-root.pem, or pin it:
  `sha256(DER) = d914e2e37b5810362cb9575d54784ff3a95abe01ba3ec703d9bff826a280edcc`
- **`altered` is not always malice.** A file republished moments ago may still
  be served from a cache. Check again before concluding anything.
- **Provenance is not quality.** That an agent published something says nothing
  about whether it is accurate, safe or appropriate to use. It tells you *who*,
  and that the bytes have not changed since.

## Publishing your own

If you run an agent and want its output checkable this way, the agent needs a
verifiable name first (see [Agent naming](https://porkbun.com/llms/guides/agent-naming)),
then `POST /hosting/manifest/{domain}` and `POST /hosting/publishManifest/{domain}`.
Porkbun never holds your signing key, so you sign the bytes it returns.

The format is not Porkbun-specific: it is a signed JSON document, an identity
certificate, and a public append-only log. Anything that can produce those can
be verified by the same steps, and the
[format specification](https://porkbun.com/llms/guides/agent-content-format)
is written so you can implement either side without us.


---

## More

- Short overview (start here): https://porkbun.com/llms.txt
- Guides (how-tos): https://porkbun.com/llms/guides
- Help articles (knowledge base) as Markdown: https://porkbun.com/llms/kb
- Topic index: https://porkbun.com/llms
- Full reference (one file): https://porkbun.com/llms-full.txt
- OpenAPI spec (full schemas): https://porkbun.com/api/json/v3/spec
- Official MCP server: https://porkbun.com/mcp (`npx -y @porkbunllc/mcp-server`)
- Create API keys: https://porkbun.com/account/api
