Reference

Artifact Anchoring

Prove an artifact existed exactly as-is at a moment in time, and make any later tampering detectable. A contract, an invoice, a medical prescription, an insurance claim, an image, an audio recording: you hash it locally, register only the sha256, and the registration joins the same tamper-evident audit chain as Fidacy's payment verdicts, checkpointed to the Bitcoin blockchain. The file itself never leaves your machine.

What this is, and what it is not

Anchoring answers one question with cryptographic force: has this exact content changed since it was registered? If the hash of the file in front of you matches the anchored record, the content is byte-for-byte the same as the registered hash. A confirmed Bitcoin checkpoint makes a later rewrite of that checkpoint detectable. It does not prove who created the file, whether the file was truthful, or that every relevant file was registered.

It is not content analysis. Fidacy does not read, scan or judge the artifact, and cannot: it only ever sees the hash. That is also why it is safer to handle than the original file. A hash is not the file itself, but it can still be a correlatable identifier; treat labels, subjects and hashes according to your data-handling policy.

Register an artifact

Authenticated with your engine API key (scope assess:write). Hash the file locally, then:

curl -s https://api.fidacy.com/v1/artifacts \
  -H "Authorization: Bearer $FIDACY_ENGINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sha256": "'"$(shasum -a 256 contract.pdf | cut -d\  -f1)"'",
    "kind": "contract",
    "label": "MSA-2026-014"
  }'

kind is one of contract, invoice, prescription, claim, document, image, audio, video, conversation, custom. label is an optional short reference (an invoice number, a case id). Do not put PII in it.

The response is your receipt:

{
  "artifactId": "c2e3e05f-…",
  "kind": "contract",
  "sha256": "9f2a…",
  "subject": "agent:default",
  "ts": "2026-07-03T08:17:41.512Z",
  "digest": "e3b0…",
  "audit": { "seq": 140, "hash": "189a990b…" },
  "anchor": { "status": "queued" },
  "receipt": "<compact JWS, EdDSA>"
}

The anchor lifecycle

• ·queued: the registration is on the hash chain, waiting for the next checkpoint run.
• ·anchoring: a checkpoint covering your record was submitted to the OpenTimestamps calendars.
• ·confirmed: the checkpoint's Merkle root is in a Bitcoin block. Any later alteration becomes detectable against the anchored record and inclusion proof.

Check status any time:

The second form answers the verification question directly: has this exact content been anchored by my account? Hash the file you were handed, look it up. No match where you expected one means the file changed since anchoring. That mismatch is the tampering signal.

Verify offline, without trusting Fidacy

The receipt is reproducible from public parts:

• ·The chain digest is sha256(JCS({v:"fidacy.artifact.v1", artifactId, kind, sha256, subject, ts})) (JCS = RFC 8785 canonical JSON). Recompute it from the receipt fields and compare with digest.
• ·The receipt JWS verifies against the public JWKS (EdDSA, by kid), same recipe as Verify a Payload.
• ·The audit record at audit.seq carries that digest inside the append-only audit chain. Its checkpoint can be verified against the returned anchor data once confirmation is available.

Conversation receipts

A chatbot session is an artifact too, and for insurers, hospitals and banks it is the one that ends up in disputes. The @fidacy/session SDK hashes every message into a running chain locally (the transcript never leaves your infrastructure), anchors the final digest at session close with kind: conversation, and gives you a verify link to hand the customer.

import { createSession } from "@fidacy/session";

const session = createSession({ label: "case-4711" });
session.add("user", "I want to file a claim for water damage.");
session.add("assistant", "I can help. When did it happen?");

const receipt = await session.anchor({ apiKey: process.env.FIDACY_ENGINE_API_KEY });
session.verifyUrl(); // https://fidacy.com/verify?sha256=…  ← give this to the customer

The transcript digest recipe is public (documented in the package README): anyone holding the exported transcript recomputes the hash offline with digestTranscript(messages) and checks it on the verify page. Editing one character of one message breaks the match.

Public verification API

The consumer side needs no account and no key. Both endpoints are open and CORS-enabled; the verify page is built on them.

Returns whether the hash was anchored, plus kind, timestamp, chain position and Bitcoin checkpoint state per record. No org, label or subject data is ever exposed.

Body { "receipt": "<compact JWS>" }. Verifies the EdDSA signature against the JWKS, recomputes the digest recipe for internal consistency, and returns the current anchor state of the covered chain record. A forged or altered receipt returns { "valid": false }.

From an agent (MCP and OpenClaw)

The @fidacy/mcp server and the OpenClaw plugin expose artifact tools including anchor_artifact and check_artifact. Both take a file path, hashed locally with streaming SHA-256 so even a large video never loads into memory, or a precomputed sha256. Your agent can anchor the contract it just generated, or verify the invoice it was just handed, as a single tool call.

# the agent side of a dispute-proof document flow
anchor_artifact { "path": "./contracts/msa-2026-014.pdf", "kind": "contract", "label": "MSA-2026-014" }
# … months later, when the counterparty presents "the same" contract:
check_artifact  { "path": "./inbox/msa-2026-014.pdf" }
# NOT FOUND → the bytes changed since anchoring. That is your answer.