Introducing Attest API reference Integrations AI assistants Gmail

On this page

Documentation

Introducing Attest.

Attest is a Web2 platform that delivers Web3 guarantees as a service. It gives documents, signatures, credentials, and facts proof that anyone can check and no one can forge, while everyone involved uses it like any other app.

You sign agreements with your fingerprint, create permanent receipts for files and events, prove facts without revealing them, issue credentials people carry into wallet apps, seal documents until a deadline or an approval, and collect anonymous answers that are each proven to come from someone eligible. Behind each of those, Attest carries out everything a blockchain requires: a wallet for every user, gas for every transaction, anchoring on Base mainnet, and independent proof verification on zkVerify. You never see a wallet, a seed phrase, or a token.

Why it exists

Digital trust is broken in three ways.

Most digital evidence depends on whoever keeps it. A log file can be edited. A timestamp is whatever the server says. A record is only as good as the system that holds it. When it matters, you end up trusting whoever holds the database, and hoping they never make a mistake, get breached, or go out of business.

Blockchains fixed that: records no one can alter, verifiable by anyone, with no one in charge. But they ask everyone to become crypto experts first. Wallets, seed phrases, gas fees, bridges between networks, tokens to buy. Most people and most companies will never do that, so the guarantees stay out of reach.

And there's a third problem: proof usually means exposure. To show you have a contract, you show the contract. To show a scan passed, you share the scan.

Attest exists to close all three gaps at once: evidence that can't be faked, an experience anyone can use, and proof that reveals only what you choose.

Vision

The guarantees of Web3, the user experience of Web2.

We believe verifiable truth should be a utility, as ordinary as email and as easy as signing in with your fingerprint. Every agreement, record, and claim that matters should be checkable by anyone, forever, without trusting the company that issued it, including us.

Our principles follow from that. Evidence must outlive its issuer: if DataHubz disappeared, every record would still verify. Privacy is the default: we can't read your documents, and proofs disclose only what you decide. And the cryptography is done properly, not approximately: each user has their own wallet and keys, and every ceremony a blockchain or proof system requires is carried out and recorded.

Problems it solves

From “trust me” to “check for yourself”.

A signature can be disputed.

Each signature is made by the signer's own passkey over a statement naming the document, the signer, and the time, then anchored from the signer's own wallet. Anyone can check it.

A file can be altered after the fact.

A receipt proves the exact content existed, unchanged, at a point in time. Change one byte and verification fails.

Confidential deals can't be proven without disclosure.

A zero-knowledge proof shows who you have an agreement with, and when, while the agreement stays private.

Records depend on the vendor that holds them.

Anchors live on a public blockchain. Anyone can verify them without an account, or without Attest at all.

Blockchain is too hard to adopt.

Attest runs wallets, gas, bridging, and proof submission for you. Users sign in with a passkey or an email link.

Cloud services can read what you upload.

Documents are encrypted in your browser before upload and stored only as ciphertext. You choose how private: with Private from the start, only you and your signers can ever open them.

AI agents act without an audit trail.

Each agent action can become a receipt: what was done, when, and who authorized it.

Certificates and badges are easy to fake, and revocations go unnoticed.

Proof Cards are signed credentials anyone can check, with revocation status read live and every change anchored.

Bids and proposals can be peeked at before the deadline.

Sealed submissions are time-locked with drand: no one can open them before the deadline, not even the organizer or Attest.

Sensitive documents rely on one person to release them.

Approval releases and continuity vaults split the key among several people, so no one, Attest included, can open them alone.

Anonymous surveys either leak identities or let anyone answer.

Verified Forms prove each answer came from someone on the list, once, without revealing who.

What it's good for

Anywhere proof matters more than paperwork.

Contracts and legal

NDAs, service agreements, and consents signed with evidence that holds up, with certificates anyone can check.

Compliance and audit

Prove a control passed, a report was final, or a scan was clean, without handing over the underlying data. Publish third-party certificates, like a security assessment passed, that anyone can check from the PDF.

AI agents

An accountable trail of what automated agents did, when, and on whose authority.

Media provenance

Show that an image, video, or recording is the original and hasn't been edited since a point in time.

Software supply chain

Receipts for builds and releases, so anyone can confirm the artifact they run is the one you shipped.

Confidential partnerships

Prove a relationship exists, and since when, without disclosing its terms or the other parties.

HR and procurement

Offer letters, policies, and supplier agreements with verifiable acceptance.

Training and credentials

Certifications, supplier approvals, memberships, and employment, as cards people carry and verifiers check live.

Tenders and applications

Collect bids, proposals, or applications that stay sealed until the deadline, with receipts proving they arrived on time.

Business continuity

Handovers, account access, and instructions released only with enough approvals, or if someone stops checking in.

Governance and feedback

Team pulses, committee votes, and member feedback with honest, anonymous answers from exactly the right people.

Platforms and SaaS

Add verifiable records and signing to your own product through the API, with no blockchain work on your side.

What you can do

Eight capabilities, one platform.

In the dashboard, the left sidebar groups them: Evidence (agreements, receipts, proofs), Credentials (Proof Cards), Confidential (sealed submissions, approval release, continuity vault), Collect (Verified Forms), and Build (developers). Your organization, security, and plan are under Settings.

Create receipts

Turn any file or record into a permanent, verifiable receipt, from the dashboard or one API call.

Documents Images Video Audio Events Agent actions Code artifacts Custom

Sign agreements

Send an end-to-end encrypted document to up to 20 signers, in any order or a set order. Completed agreements are anchored and get a certificate.

Prove facts in zero knowledge

Prove you're a party to an agreement, or that you have one with a specific party, completed on a given day, while everything else stays private. Proofs are verified on zkVerify.

Issue Proof Cards

Issue training certificates, supplier approvals, memberships, and employment cards from your organization. Each is a W3C Verifiable Credential and an SD-JWT VC: holders reveal only the fields they choose, add it to wallet apps through OpenID4VCI, and present it through OpenID4VP. Suspend or revoke any time; every issuance and status change is anchored, and the holder is emailed.

Issue certificates

Certify that a company passed an assessment, an audit, or a standard, as of a date. The people you name review and sign every statement with their passkeys; your organization signs it as a W3C Verifiable Credential; Attest renders the PDF with a QR code and anchors it on Base from your organization's wallet. Its public page re-runs every check in the reader's browser, and dropping the PDF on the verifier finds it. Revocable, and replaceable by a newer one.

Share on your conditions

Sealed submissions: collect files no one can open before your deadline. Approval release: a document that opens for its recipients only after k of n approvers approve, and not before a date if you set one. Continuity vault: information released to the people you choose only if you stop checking in and your trustees confirm. Everything is encrypted in the browser.

Collect Verified Forms

Ask a group questions and get anonymous answers, each carrying a zero-knowledge proof that it came from someone on your list (or a holder of a Proof Card), once. Proofs are verified on zkVerify; anyone who can see the results can re-check every one.

Verify anything

Check any receipt, agreement, proof, credential, or certificate for free, with no account: by ID, by fingerprint, by dropping the original file, or by pasting a credential.

Integrate with the API

Most of the dashboard is available as a REST API, so your software can create, prove, issue, seal, and verify on its own. What needs a person's passkey (signing, approving, checking in) stays with that person.

How it works

How each one works.

A receipt

01
Fingerprint
Your file is hashed on your device. Only the fingerprint is sent.
02
Record
A receipt is created at once, with its ID and time.
03
Batch
Within about 10 minutes on Free (at once on Pro), your records are sealed into a Merkle tree.
04
Anchor
The root is written to Base mainnet from your own wallet.

An agreement

01
Encrypt
The document is encrypted in your browser and locked to each party's key.
02
Sign
Each signer reviews it and signs with their passkey; each signature is anchored from their own wallet.
03
Complete
The signed state is fingerprinted and becomes a receipt.
04
Anchor
It's anchored on Base from the creator's wallet, with a public or private certificate.

A zero-knowledge proof

01
Commit
Completed agreements join an anchored commitment root.
02
Prove
You choose a statement; a Groth16 proof is generated against that root.
03
Verify
The proof is submitted to zkVerify for independent verification.
04
Share
Anyone can check it, and learns only the statement.

A Proof Card

01
Issue
Your organization signs the card with its own key, and the issuance is anchored.
02
Hold
The holder accepts it in Attest or adds it to a wallet app.
03
Present
They share or present it, revealing only the fields they choose.
04
Check
Verifiers check the signature and read its revocation status live.

A certificate

01
Create
Your organization sets out the statements, as of a date, and names who signs.
02
Sign
Each signer reviews every statement and signs it with their passkey.
03
Issue
Your organization signs it, the PDF is rendered, and both are anchored on Base.
04
Check
Anyone opens it or drops its PDF on the verifier; every check runs in their browser.

A sealed or conditional release

01
Encrypt
The file is encrypted in the browser; Attest stores it only as ciphertext.
02
Lock
The key is time-locked with drand, split among approvers or trustees, or both.
03
Condition
The deadline passes, or enough people approve with their passkeys.
04
Open
Only the intended people can open it, in their own browser.

A Verified Form

01
Join
Each eligible person creates a private identity for the form in their browser.
02
Answer
Their browser proves they're on the list, without saying who, and sends the answer.
03
Verify
Attest and zkVerify verify every proof; a second answer from anyone is refused.
04
Anchor
The terms, the group, and the final results are anchored on Base.

Trust model

What we can see, and what we can't.

Attest cannot see

The content of your documents: we store them only as ciphertext, and you choose how private. Private from the start means only you and your signers can ever open one; Ready now lets a new signer open it right away, end-to-end encrypted from the moment they do. Ready now keeps a sealed copy of the document's key with our signing service until the signer first opens it, then deletes that copy.
Your private key, passkey secrets, or recovery phrase: they never leave your device unencrypted.
The document keys your devices pass to new signers: the copies we keep for those devices are encrypted to keys made on them, which never leave them.
The content behind a receipt: you send its fingerprint, not the file.
What a zero-knowledge proof keeps hidden: it isn't in the proof.
Sealed submissions, approval releases, and vault contents: they're encrypted to the people you chose.
Which answer in a Verified Form came from which person.

Attest does see

Account emails; each agreement's title, file name, size and type, and the sender's note; signers' emails and names; where fields are placed; and when each step happened.
Fingerprints, claims, and metadata you attach to receipts.
The statements you choose to reveal in a proof.
Proof Cards you issue (the issuer signs them; the holder chooses what to share).
Certificates your organization issues: they're public by design, with their statements and signers' names.
Who submitted to a sealed call, who approves or receives a release, who is named in a vault, and when each acted.
Who is invited to a Verified Form and who joined, and when requests reach our servers. We don't link a member's visit to their answer.
The wallet keys that anchor records, held only by a separate signing service. It can sign nothing but anchors, key directory roots, and capped network-fee top-ups; the app you use holds no wallet keys at all. It also holds the delivery key for Ready now, which it uses only to lock a document key to the key the newest key directory root on Base holds for that signer, each sealed copy only ever to one key.

What you don't have to trust: that we kept the record honestly. Every anchor is on a public blockchain and every proof is checked by zkVerify, so a record can be verified with standard tools even if Attest is offline or gone. The technical details on each verification page show exactly what to check. Records anchored before Attest moved to Base, in October 2026, were anchored on Horizen, and they stay verifiable with Base alone: Attest keeps a proof of each one that checks against the output roots Horizen's L3 posted to Base, so no Horizen node is needed.

Nor that we handed you the right key. Before your browser encrypts anything to someone, it checks their public key against Attest's public key directory, whose roots are published on Base and can never be replaced, and it refuses a key that isn't the published one. Every person's browser checks their own entry in every root, so a key slipped in for them, by anyone, Attest included, raises an alarm. You can also compare safety numbers with the people you share with on the Security page.

Who a document is unlocked for: your devices unlock it automatically only for the addresses sealed into it when you sent it (encrypted under its key, so Attest can't add one), and Attest's server refuses an automatic unlock for any other address. By hand, you confirm each address in the app, and for an address the document wasn't sealed to (one sent without automatic unlocking, or a signer added later), Attest's server stores the unlock only with your passkey's confirmation of that address and the key it goes to, signed in the unlock's own prompt and used once. Through the API, an API key unlocks by hand only documents created through the API. What that doesn't cover: an address sealed at Send is unlocked by hand without the extra confirmation; documents created before October 14, 2026 can be unlocked with an API key; and script running in your signed-in tab while your key is unlocked could read what that tab can. That last one is what each page's script policy is for: no inline script runs but the page's own.

With Ready now, the new signer doesn't wait for your devices: when they set up their key, our signing service locks the document key to it, only to the key the newest key directory root on Base holds for that address, and each sealed copy only ever to one key. The sealed copy is deleted then, and also when the agreement is withdrawn, declined or expires, or the signer resets their key, in which case you check the new key and unlock it yourself.

Nor the code that unlocks documents for new signers while Attest is closed. It runs in your browser as a service worker, served at attest.datahubz.com/sw.js, and Attest serves a build only once it's anchored on Base. Its source is public, with the build that makes the exact bytes served: the attest-verifier repository on GitHub (DataHubz/attest-verifier, folder unlock-worker). To check the one you get: fetch /sw.js, take the SHA-256 of the file and the version from its first line, and ask the AttestRegistryV3 contract (0xa4B9c8FaEcF6adAed5bDc6136D3AB55F8791B80e) with anchoredAt for Attest's platform wallet (0xdEa7B859DcBd34deB8dc910b5b36d6ACdBeC6F3a) and the SHA-256 of “attest.unlock-worker.v1|[version]|[file SHA-256]”, or run the repository's sw-monitor.mjs with --expect and the SHA-256 you built. The Security page shows the version your browser runs and the fingerprint of the build Attest serves; the check runs outside it, because a page can't vouch for itself.

Taxonomy

The vocabulary of Attest.

Records

Fingerprint: The SHA-256 hash of a file or text: a 64-character code that changes completely if a single byte changes. Attest works with fingerprints, not your content.
Receipt: A permanent record that content with a given fingerprint existed, unchanged, at a point in time. IDs start with rcpt_.
Kind: What a receipt is about: Document, Image, Video, Audio, Event, Agent action, Code artifact, or Custom.
Claim: A short human statement attached to a receipt, such as “Q3 report, final”.
Superseding receipt: A correction. It points to the receipt it replaces; nothing is ever deleted or edited.

Anchoring

Batch: The records created by one user in one 10-minute window, sealed together.
Merkle tree and root: A structure that combines a batch's fingerprints into a single 32-byte root. Each record gets an inclusion proof that ties it to that root.
Anchor: The blockchain transaction that records a root on Base mainnet. From then on, the record can be verified without Attest.
User wallet: The blockchain account Attest creates and runs for each user. Every anchor is sent and paid from the owner's own wallet.
Treasury: Attest's pool of funds that tops up user wallets with gas, so no user ever handles crypto.

Agreements

Agreement: A document sent to one or more signers. IDs start with agr_.
Signer: A party who signs, by email link or, for the creator, in the dashboard. Agreements can be signed in any order or in a set order.
Signing link: The private link emailed to a signer. It lets them sign that agreement only; it never logs anyone in.
Certificate: The record of who signed and when. Public (anyone can verify it) or private (only the parties can see it; anyone else who looks it up is told it exists and is private).
Passkey signature: How a signer signs: their passkey signs a statement naming the document's fingerprint, the signer, and the time. It's stored with the agreement, anchored from the signer's wallet, and anyone can re-check it in their browser.
Completion: When the last signer signs, the agreement's signed state is fingerprinted, turned into a receipt, and anchored.

Keys and privacy

Key: Each user's encryption key pair. The private half is created in the browser and stored only in encrypted form; Attest can't use it.
Passkey: A credential on your device, unlocked by Face ID, Touch ID, Windows Hello or the device PIN. It signs you in and unlocks your key. You can have one per device.
Recovery phrase: A backup that unlocks your key if you lose your passkeys. Shown once; Attest can't recover it.
Document key: A random key that encrypts one document. It's locked separately to each party's key.
Ready now and Private from the start: How a signer new to Attest gets a document, chosen when you send it. Every document is end-to-end encrypted, and you choose how private: Private from the start means only you and your signers can ever open it; Ready now lets a new signer open it right away, end-to-end encrypted from the moment they do. Ready now keeps a sealed copy of the document's key with our signing service until the signer first opens it, then deletes that copy.
Automatic unlocking: If you turn it on, your own devices pass a document's key to a new signer automatically, once their passkey is set up, after the same checks your browser makes when you unlock it yourself, and only for the addresses sealed into the document when you sent it (Attest's server refuses any other). It's on or off for each document you send; each device's keys are made on it and never leave it, and you turn a device off at any time on your Security page.
Key directory: Attest's public list of everyone's encryption key, with roots published on Base that can never be replaced. Your browser checks a person's key against it before sharing anything, and checks your own entry in every root, so a swapped key is refused or found.
Safety number: 60 digits you and another person both see only if each of you has the other's real key. Compare it on the Security page, in person or on a call.
Grant: Giving a signer access to a document after they set up their key: one of the sender's devices, automatically, or the sender's browser, when they unlock it by hand, locks the document key to the signer's key. With Ready now, our signing service does it, only to the key the newest key directory root on Base holds for the signer's address.

Proofs and verification

Zero-knowledge proof: Mathematical proof that a statement is true without revealing anything else. Attest uses Groth16 proofs. IDs start with azk_.
Commitment root: A published, anchored summary of a tree of up to 65,536 completed agreements. Proofs are made against it, so they can be checked without seeing any agreement.
zkVerify: An independent network that verifies zero-knowledge proofs. Attest submits every proof there: agreement proofs, compliance proofs, and Verified Form answers.
Compliance proof: A zero-knowledge proof about a security scan, such as “no critical vulnerabilities”, that keeps the scan's numbers private: only whether the claim holds is public, and the scan is bound by a salted commitment you can open for an auditor. It runs on the security-scan circuit from Hubz VCE, a DataHubz project.
Certificate: An organization's signed attestation about a subject as of a date, such as a security assessment passed: signed by named people with their passkeys and by the organization, rendered as a PDF, anchored on Base, and public. Its PDF's fingerprint finds it on the verifier. IDs start with cert_.
Verification: Checking any of the above, free and without an account, on the Attest verifier, through the API, or directly on the blockchain.

Proof Cards

Proof Card: A credential your organization issues: training, supplier approval, membership, employment, or custom. IDs start with cred_.
Issuer: The organization that signs a card, identified by a did:web address with its own signing key.
Selective disclosure: Revealing only some of a card's fields while the signature still verifies.
Status list: A published, signed list that says whether each card is valid, suspended, or revoked. Every version is anchored.
SD-JWT VC: The second format every card is issued in, read by wallet apps (IETF, following the DIIP profile).
Wallet app: An app that holds cards. Cards move into one through OpenID4VCI and are presented from it through OpenID4VP.
Presentation request: Asking someone to present a card, with the fields you need. Answered only with holder binding: proof the holder controls the card.

Confidential sharing

Sealed call: A request for submissions that can't be opened before its deadline.
Time lock: Encryption only a future drand round can open. drand, run by the League of Entropy, publishes each round's key at a fixed time.
Approval release: A document that opens for its recipients once enough approvers approve, and not before a date if one is set.
Threshold: How many people must act together, like 2 of 3. The key is split with Shamir's secret sharing, so fewer reveal nothing.
Continuity vault: Information released to beneficiaries only if its owner stops checking in and enough trustees confirm.
Check-in: The vault owner's periodic passkey tap that keeps a vault closed. It also cancels any confirmations in progress.
Trustee and beneficiary: Trustees confirm a release when it's needed; beneficiaries are the only people who can open it.

Verified Forms

Verified Form: Questions for a known group, answered anonymously and at most once per person. IDs start with frm_.
Group: The public fingerprints (commitments) of everyone who joined. Proofs show membership of this group.
Nullifier: A value each member's proof produces for a given form. The same person always produces the same one, so a second answer is refused, without revealing who.
Join first, then answer: Joining closes when answering opens, so the moment someone joined says nothing about their answer.
Evidence file: Every response with its proof, and the group, so anyone who can see the results can re-check them.

Plans

Start free.

Free

2 documents sent for signature, in total. For the other tools, 10 records a month: receipts, compliance proofs, Proof Cards, and certificates you create, and sealed calls, releases, vaults, and forms. Each document you send for signature counts against both: it uses one of the 2 documents and one of that month's records. Signing, Share proof, approving, answering, and verifying never use up records. Records are anchored within about 10 minutes. Attest pays the blockchain costs. Verification is always free, for everyone.

Signing

$5 a month for 20 documents sent for signature a month, with every signing feature: sealed copies, certificates, Share proof and free verification. The people who sign never pay. Cancel any time.

Pro

10,000 records a month, API access at scale, and priority anchoring: each record is on the blockchain within seconds, in its own transaction. See Plans & usage in the dashboard.

Next steps

Try it.

Create an account

Your email is all it takes.

Verify something

No account needed.

Read the API reference

Everything, programmatically.

Start free