Turn any hash into a signed, RFC 3161 timestamped proof of existence.

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 an independent RFC 3161 timestamp authority, which returns a signed timestamp token. The result is a timestamp proof that fixes your hash to a precise time. Anyone can verify it, with our open-source verifier or standard RFC 3161 tooling, without trusting us at all.

Timestamp 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 account, these run as-is against dynamicfeed.ai today.

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

# 2) time-stamp 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:"timestamped" + a timestamp_token_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}}'

import hashlib, requests

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

# 2) time-stamp 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"])              # "timestamped"
token = proof["timestamp_token_b64"]  # save this, it IS your proof
print(proof.get("tsa"), proof.get("serial"))

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

import { createHash } from "node:crypto";

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

// 2) time-stamp 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);               // "timestamped"
const token = proof.timestamp_token_b64; // save this, it IS your proof
console.log(proof.tsa, proof.serial);

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

# timestamped: sha256("dynamicfeed notary quickstart demo"), abbreviated
{
  "backend": "rfc3161",
  "tsa": "http://timestamp.digicert.com",
  "digest_sha256": "09207fd234c0ab808f2d8861a5d55f7cc8497229cb4353f997d2ee1e75604880",
  "status": "timestamped",
  "timestamped_at": "2026-06-14T03:21:07Z",
  "serial": "0x6a3f1c7e",
  "hash_algorithm": "SHA-256",
  "timestamp_token_b64": "MIIFxQYJKoZIhvcNAQcCoIIFtjCCBbICAQMxDzANBglghkgBZQMEAg…",
  "note": "Signed timestamp token from an independent RFC 3161 authority.
           'timestamped' = the authority has bound the hash to a precise time
           and returned the token instantly, no wait. The token verifies the
           hash against the authority independently. Time-stamps the HASH only,
           never the data.",
  "signature": {
    "alg": "Ed25519",
    "key_id": "df-ed25519-6ca0de29113b",
    "canonicalization": "json-sorted-compact",
    "sig": "<base64url signature from the current response>"
  }
}

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 timestamp we issue is checkable three independent ways:

• In the browser. Our /proof page verifies an Ed25519 signature live in your browser, fetch, paste, or tamper-test a record and watch it pass or fail.
• With the open-source verifier. Published on npm, PyPI and crates.io (@dynamicfeed/verify · dynamicfeed-verify), plus scripts/verify_awareness.py in the public repo, run it in your own code, offline.
• Against the timestamp authority itself. The signed timestamp token verifies your hash against the independent RFC 3161 authority using standard tooling such as OpenSSL, no Dynamic Feed involved at all.
• In the public notary log. An append-only, hashes-only transparency log, browse it, or read it via GET /v1/notary/log, /v1/notary/log/{idx} and /v1/notary/log/{idx}/proof. Alter one entry and every hash after it breaks.

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 timestamp primitive underneath it.

Existence at a time. Not truth.

Free and keyless today. Self-serve at scale.