NOTARY API · LIVE·SIGNED · BITCOIN-ANCHORED · KEYLESS
ED25519 · OPENTIMESTAMPS·--:--:-- UTC
Home  /  Notary  /  Quickstart
NOTARY API · QUICKSTART

Turn any hash into a signed, Bitcoin-anchored proof of existence.

Send us a SHA-256 — never your data. We sign it and anchor it to Bitcoin via OpenTimestamps, and hand back a timestamp proof that the record existed, unchanged, at time T — independently verifiable by anyone, even against us. Keyless. Copy-paste. Works right now.

jump to the quickstart the witness layer
WHAT IT DOES

One call. A proof anyone can check.

You compute a SHA-256 of a file, a record, or any string. You send us that digest — or a JSON snapshot whose canonical SHA-256 we compute for you. We sign it with our Ed25519 key and submit the hash to the OpenTimestamps calendars, which fold it into a Bitcoin block. The result is an .ots proof that timestamps your hash against the Bitcoin chain. Anyone can verify it — with our open-source verifier or standard OpenTimestamps tooling — without trusting us at all.

1

Hash it locally

Compute a sha256 of your file or string on your own machine. Only the 64-hex digest is sent — your bytes never leave your infrastructure.

2

We sign & anchor it

One POST /v1/anchor. We Ed25519-sign the digest and submit it to the OpenTimestamps calendars, which commit it toward a Bitcoin block.

3

Verify, forever

You get an .ots proof. After a block confirms (~10–60 min), upgrade it once to its block attestation — then anyone can re-check it independently.

hashes only — and that's the point

The anchor endpoints take a hash, never your data. Send a 64-hex SHA-256 and we anchor exactly that fingerprint. Your underlying file, record or payload stays entirely on your side — there is nothing for us to read, store or leak. Privacy by construction, proof by mathematics.

QUICKSTART

Anchor your first hash in 60 seconds.

Pick your language. Each block hashes a string locally, sends only the digest to the real POST /v1/anchor, and prints the proof. No key, no signup, no wallet — these run as-is against dynamicfeed.ai today.

SHELL · POST /v1/anchorCOPY
# 1) hash a string (or a file: shasum -a 256 myfile.pdf) locally
DIGEST=$(printf 'invoice #4471 — A$12,400 — 2026-06-14' | shasum -a 256 | cut -d' ' -f1)

# 2) anchor JUST the digest — your data never leaves your machine
curl -s https://dynamicfeed.ai/v1/anchor \
  -H "Content-Type: application/json" \
  -d "{\"digest_hex\":\"$DIGEST\"}"

# → returns status:"pending" + a proof_ots_b64 you save.
# (Don't have a hash handy? Send a JSON snapshot instead and
#  we compute its canonical SHA-256 for you:)
curl -s https://dynamicfeed.ai/v1/anchor \
  -H "Content-Type: application/json" \
  -d '{"snapshot":{"gauge":"river-7","level_m":2.41}}'

# 3) ~1 block later, upgrade the pending proof to its Bitcoin attestation
curl -s https://dynamicfeed.ai/v1/anchor/upgrade \
  -H "Content-Type: application/json" \
  -d "{\"proof_ots_b64\":\"$SAVED_PROOF\"}"
import hashlib, requests

# 1) hash your data locally — only the digest is ever sent
data = b"invoice #4471 — A$12,400 — 2026-06-14"
digest = hashlib.sha256(data).hexdigest()

# 2) anchor the digest (hashes only, keyless)
r = requests.post("https://dynamicfeed.ai/v1/anchor",
                  json={"digest_hex": digest}, timeout=30)
proof = r.json()
print(proof["status"])          # "pending"
ots = proof["proof_ots_b64"]      # save this — it IS your proof

# (Alternatively, hand us a snapshot and we hash it canonically:)
# requests.post(URL, json={"snapshot": {"gauge": "river-7", "level_m": 2.41}})

# 3) ~1 block later, upgrade to the Bitcoin block attestation
up = requests.post("https://dynamicfeed.ai/v1/anchor/upgrade",
                   json={"proof_ots_b64": ots}, timeout=40).json()
print(up["status"], up.get("bitcoin_block_height"))
import { createHash } from "node:crypto";

// 1) hash your data locally — only the digest leaves your machine
const data = "invoice #4471 — A$12,400 — 2026-06-14";
const digest = createHash("sha256").update(data).digest("hex");

// 2) anchor the digest (hashes only, keyless)
const res = await fetch("https://dynamicfeed.ai/v1/anchor", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ digest_hex: digest }),
});
const proof = await res.json();
console.log(proof.status);             // "pending"
const ots = proof.proof_ots_b64;       // save this — it IS your proof

// (Or send a snapshot and we compute its canonical SHA-256:)
// body: JSON.stringify({ snapshot: { gauge: "river-7", level_m: 2.41 } })

// 3) ~1 block later, upgrade to the Bitcoin block attestation
const up = await fetch("https://dynamicfeed.ai/v1/anchor/upgrade", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ proof_ots_b64: ots }),
}).then(r => r.json());
console.log(up.status, up.bitcoin_block_height);
REAL RESPONSE · POST /v1/anchor · captured livePENDING → BITCOIN
# anchored: sha256("dynamicfeed notary quickstart demo"), abbreviated
{
  "backend": "opentimestamps",
  "chain": "bitcoin",
  "digest_sha256": "09207fd234c0ab808f2d8861a5d55f7cc8497229cb4353f997d2ee1e75604880",
  "status": "pending",
  "bitcoin_block_height": null,
  "calendars_committed": 3,
  "attestations": ["PendingAttestation"],
  "proof_ots_b64": "AE9wZW5UaW1lc3RhbXBzAABQcm9vZgC/ieLohOiSlAEICSB/0jTAq4…",
  "note": "Bitcoin timestamp via OpenTimestamps. 'pending' = calendars have
           committed the hash and will fold it into a Bitcoin block (~10–60 min);
           call /v1/anchor/upgrade to fetch the block attestation. The .ots proof
           verifies the hash against Bitcoin independently. Anchors the HASH only —
           never the data.",
  "signature": {
    "alg": "Ed25519",
    "key_id": "df-ed25519-4cb32e72f333",
    "canonicalization": "json-sorted-compact",
    "sig": "EsrcIAzzmjc4GZwUu2jz8-E4JsV5R4C90zm5YHxBd9nK…"
  }
}
HOW VERIFICATION WORKS

Anyone can re-check it — including against us.

A proof is only worth anything if a third party can verify it without your help. Every anchor we issue is checkable three independent ways:

Want the continuous, witnessed-feed version — register a feed and have every change notarized automatically? That's the notary witness layer; this page is the bare-metal anchor primitive underneath it.

WHAT IT PROVES — AND WHAT IT DOESN'T

Existence at a time. Not truth.

read this before you build on it

An anchor proves that a specific hash existed, unchanged, at a specific time — and that any later edit is detectable. It does not prove that the data behind the hash is true, accurate or correct. We are a witness, not an auditor: if your source is wrong, an anchored record proves exactly what it said and when, which is precisely what you want in a dispute. We see hashes only, never the underlying data, so we make no claim about its content. This is verifiable proof-of-existence — never a guarantee of correctness or safety.

WHAT IT COSTS

Free and keyless today. Talk to us at scale.

Right now · free + keyless

Anchoring via OpenTimestamps is currently free and keyless — no wallet, no card, no account. OpenTimestamps batches your hash into a Bitcoin block off the hot path, so the cost to anchor is effectively zero and we pass that on. Start with the quickstart above; nothing to sign up for.

At volume · managed · SLA → talk to us

For high-volume, managed, or SLA-backed anchoring — guaranteed upgrade-to-block monitoring, retention, throughput commitments, or anchoring wired into a product you ship — talk to us and we'll scope it. We won't pretend there's a checkout where there isn't one; paid is a conversation, not a paywall.

START HERE

Anchoring at scale?

The quickstart above is free and keyless — use it now. If you need high-volume, managed, or SLA-backed anchoring, tell us a little and we'll scope it on a short call. No checkout; we agree the shape first.

Prefer email? [email protected]