A scraping and monitoring engine where every fetch produces a cryptographically signed provenance record — so one agent can prove to another exactly what it retrieved, and anyone can verify it offline. Signed by your key, on your machine. Runs complete on a single machine — no swarm, no account, no cloud required.
Python · Apache-2.0 open core · complete at N=1 · zero mandatory cloud
Below is a real inverba-record. Verification runs right here in your browser — plain SHA-256 and Ed25519, no Inverba install, no trust in us required. Then flip one character and watch the math catch it.
The response is captured with its fetch facts: status code, final URL after redirects, content type, timestamp.
Content hash and fetch context are signed with your Ed25519 key, locally. The record is a plain JSON file you own.
A record is a standard signature over canonical JSON. Verification needs ~30 lines in any language — no Inverba install, nothing from us.
content_sha256 — commits to the exact bytes. Change one character on the page and the hash breaks.
status_code · final_url · content_type — the fetch facts, signed alongside the content: what was asked for, what came back, and in what form.
signature — binds hash and context to a specific key at a specific time. Your key, generated and held locally.
corroborations — counter-signatures from other fetchers that saw the same content. Empty at N=1; a solo record is complete without them.
Everything that makes a record provable works at N=1 — no swarm, no account, no cloud. Adding vantages deepens corroboration; it never gates the core.
When an agent hands off web data, the receiving agent verifies the signed record itself — hash, signature, fetch context — without trusting the sender, without a swarm, without asking us. Machine-checkable provenance is what lets autonomous pipelines consume each other's output safely.
Nothing below is required on day one. Solo records stay valid forever — extra vantages only add corroboration depth.
Every scheduled check produces a signed record, so a diff isn't a claim — it's two pieces of evidence. Changes are classified by significance: a flipped price is flagged material even when 99% of the page is boilerplate churn.
Inverba fetches from multiple network vantages and compares signed results. Divergence is reported with a confidence level and plausible explanations — never as certainty. A site serving datacenter IPs a different terms page is a finding; why it does so is your call.
Scale across a pool of fetchers — yours or federated — each with a trust score earned from verified history. Selective corroboration re-fetches only high-stakes pages through independent nodes, so you pay for agreement where a wrong answer is expensive, not everywhere.
Scaling adds corroboration depth. It never invalidates what you already signed.
The full core: fetch, sign, verify, change detection, C2PA export, agent-to-agent verification. A record signed at N=1 is complete evidence — valid forever, whatever you add later.
Opt-in two-party corroboration for solo users: an independent counter-signature that the notary saw the same content. In development — not yet hosted; solo records don't wait for it.
Add fetchers when you outgrow one vantage. Corroboration deepens automatically, cloaking detection gains vantages — and old records never need re-signing.
Inverba will ask before it ever contacts a notary. Decline, and it stays 100% local — that's the default today and it will stay the default. First-run consent is part of the design, because sovereignty you have to configure isn't sovereignty.
Show a competitor changed their pricing — with signed before/after records anyone can independently verify.
Document what your training corpus contained, from where and when — as C2PA manifests your compliance team can hand an auditor.
Catch a site serving different content to your crawlers than to real users — reported with confidence levels, not accusations.
Firecrawl, Crawl4AI, and ScrapeGraphAI are excellent extraction tools — use them happily. Inverba answers a different question: can you prove what you collected?
Export provenance records as C2PA Content Credentials — training-data provenance in the format EU AI Act documentation obligations expect. One command, standard manifests.
A Merkle transparency log for anchoring records — the same construction as Certificate Transparency. The design is published; the hosted log is not yet live. Records don't depend on it: they verify offline today.
A record proves what your fetcher received and signed — not what every visitor saw, and not the honesty of a compromised fetcher. We document exactly where the guarantees stop.
Read what Inverba does not prove →Paste it into a terminal. The record it produces verifies on any machine, forever — with or without us.
Everything cryptographic — fetching, signing, verifying — is Apache-2.0 and runs on your hardware. We charge for operating infrastructure you'd rather not run — flat and predictable: no credits, no per-page metering, no surprise bill. Today the only thing you can buy is the perpetual Sovereign license, because it's the only thing that already exists; the hosted tiers open when the registry goes live.
A perpetual license to the self-hostable software, running on your hardware. No recurring charge. No account required. No kill switch. The license is a signed token you own — it verifies offline against a key shipped in the software, forever, and can never be revoked.
Covers v1.x and every update to it — you own v1 forever; genuinely new major versions are a separate purchase. Hosted services (managed registry, monitoring, anchoring) stay subscription because they cost to run — and the registry is open core, so you can self-host it at no extra cost.
Licenses are signed, not served. Every paid license is a cryptographically signed token that verifies offline against a public key shipped in the software — no license server, no phone-home, works air-gapped. Pay in Bitcoin — on-chain or over Lightning — in USDC, or in Monero: prepaid, no stored payment method, no recurring charge. Crypto checkout →
A SHA-256 hash plus one Ed25519 signature — roughly 1–2 ms per fetch on commodity hardware. Network latency dominates by orders of magnitude. Registry anchoring is asynchronous and batched, off the fetch path.
No — and today it doesn't exist yet. Records are complete and verifiable fully offline. The planned registry adds exactly one guarantee: a record can't have been created after the log root that includes it. When it ships you can use ours, run your own, or skip it entirely.
Existing records remain verifiable forever against the old public key — verification never needs the private key. Rotation issues a signed continuity link from old key to new. Custody is yours; HSM and KMS backends are supported.
A record is ~2 KB of JSON. The page content itself lives wherever you choose — local disk, S3, or nowhere. The hash commits to it either way; you only need the content when someone wants to re-verify the bytes.
Canonicalize the record body (RFC 8785 JCS), check the SHA-256, verify the Ed25519 signature — about 30 lines in any language. The docs include a complete snippet.
No. Provenance is not permission. Inverba proves what you collected and when — whether you may collect or use it is a question for your counsel. Our threat model says this explicitly.
Yes — inverba-record/1 is an open specification with test vectors in the repo. Independent implementations are encouraged: a format only we can produce would defeat the point.
Five minutes to your first signed record.