In Web3, trust is not given, it’s verified. As decentralized applications grow more autonomous, the need for on-chain facts has never been greater. Whether verifying a user’s KYC status, confirming a machine’s authenticity, or managing reputation, developers require reliable infrastructure for issuing and validating claims without relying on centralized systems. Verax is that infrastructure.
Verax is an open-source attestation registry designed to be the public memory layer of decentralized networks. It enables developers, protocols, and machines to create and verify attestations – signed, on-chain claims that can be reused across the ecosystem. Instead of siloed systems, Verax provides a standardized, shared registry per network, offering consistency and composability for any use case that depends on verifiable data.
Verax was built by ConsenSys to serve Linea, but its utility now spans far beyond one network. In today’s fragmented landscape, dApps often create their own systems for verifying users or actions. This leads to redundant smart contracts, inconsistent formats, and poor interoperability. Verax solves this by introducing a modular, chain-native registry where attestations are stored once and used many times.
It is regardless of who issued them or where they originated. This shared structure reduces gas costs, streamlines development, and makes the Web3 ecosystem more composable.
Verax is designed with five components that work together to support the full lifecycle of attestations.
An attestation is a signed, on-chain statement made by one address about another. It might confirm a wallet passed KYC, that a machine completed a task, or that a user meets a score threshold. These claims are stored publicly and can be verified by any application referencing the schema they follow.
Schemas define the structure of an attestation: the fields, types, and validation rules. A schema might include a boolean status, a timestamp, and a string for jurisdiction. Once registered, any attestation tied to that schema must follow its format, enabling consistent interpretation across dApps.
Portals are optional contracts that restrict who can issue attestations for a given schema. This is useful for cases like compliance, where only approved entities, such as Sumsub or regulated institutions, should issue certain claims. Portals provide controlled access while preserving the openness of the system.
Modules add programmable logic to attestations. They can enforce conditions such as expiry, revocation, or scoring rules. This allows attestations to evolve over time or respond to on-chain activity without altering core contracts.
All Verax activity, including schemas, attestations, issuers is recorded on a single registry per chain. This registry is indexed by a public subgraph, giving developers real-time access to structured data without building their own infrastructure.
Every attestation in Verax must conform to a schema. This is the foundation that defines the shape of the data, what fields it includes, what data types are used, and what conditions must be met. A schema might include fields like subject, status, score, and timestamp, depending on the use case. Once created, a schema is published on-chain and given a unique ID, allowing any contract or application to reference it unambiguously.
If you want to control who can issue attestations using your schema, you can wrap it in a portal. A portal is a smart contract that grants permission to specific issuers. For example, only verified institutions or DAO-controlled addresses might be allowed to issue attestations under a compliance schema. Portals are optional—if you’re building an open ecosystem where anyone can issue attestations, you can skip this step.
With the schema and (optionally) the portal in place, issuers can begin creating attestations. An attestation is a signed statement about a subject that follows the format defined in the schema. It is written directly to the Verax registry, where it becomes publicly accessible. At this point, modules can also be attached to add dynamic logic like expiration dates or revocation rights. The result is an immutable, verifiable, and reusable statement stored on-chain.
Any smart contract or frontend application can read attestations from Verax and use them in their own logic. The Verax subgraph indexes all attestations, making them easily searchable. A lending protocol might check if a wallet has a certain trust score. A faucet might check if a machine has passed a bot filter. And a DAO might use attestations to confirm that voters meet participation criteria. Since everything is standardized and permissionless, the verification process is fast and reliable.
One of Verax’s most powerful features is that attestations don’t belong to a single app. Once written, they can be read by anyone. That means an identity check done in one application can be reused by others—without the user having to re-verify. This composability unlocks huge efficiencies across Web3. It also enables use cases like portable reputation, delegated access, and shared proof of history for wallets and smart contracts alike.
Verax is live on Linea and Base mainnets, with testnet deployments on Optimism, Scroll, and more. Its architecture is chain-agnostic, designed to work seamlessly on any EVM-compatible network. Each network runs a single Verax registry contract, reducing duplication and allowing all applications on that chain to share a unified source of attestation truth.
The use of standardized schemas and one contract per network enables fast integration, easier auditing, and consistent behavior across protocols. Verax also supports future extensibility, including zero-knowledge proofs, off-chain attestations, and cross-chain interoperability.
Verax is already supporting critical use cases across identity, automation, and token access.
Sumsub issues Verax attestations to users who pass KYC on Linea. These attestations follow a standard schema and are limited to Sumsub via a portal. Any compliant dApp can read these attestations, allowing users to verify once and access many services without repeating the process.
Automata uses Verax to verify machines. After verifying a device off-chain, they issue an attestation proving machine authenticity. Other apps like token faucets or staking pools can then validate that a wallet belongs to a real machine, reducing bot activity and Sybil attacks.
L2Faucet relies on Verax to prevent spam. Before sending tokens, it checks for attestations from partners like Sumsub or Automata, ensuring only verified users receive tokens. This keeps faucet services efficient and abuse-free.
Verax simplifies verification and unlocks new capabilities for Web3 developers.
Instead of writing new contracts to handle eligibility or trust, developers register a schema and use existing infrastructure. This saves time, audit costs, and gas.
Attestations created in one dApp can be used in others. A reputation score from a lending protocol can be used to access a new platform, or a verified voter attestation can serve multiple governance systems.
Verax enables machine-to-machine verification, which is critical for AI agents, autonomous dApps, and decentralized infrastructure (DePIN). Claims like “machine completed task” or “agent met criteria” can be logged and reused without centralized middleware.
Verax is open-source and governed transparently. All code, schemas, and module logic are publicly maintained. While ConsenSys initially launched the protocol, governance is shifting toward community-led models.
Proposals for new schemas, modules, or logic upgrades are open to contribution, and DAO-based governance is in the roadmap. Crucially, Verax does not define what is true—it provides tools for publishing and verifying claims. Anyone can issue or evaluate attestations based on their own criteria.
Verax offers a fast path to integration.
Example contracts, templates, and developer tools are available on GitHub. Most teams can issue and verify attestations in under an hour.
Verax is becoming the default attestation layer for EVM chains, but its roadmap is broader.
Verax replaces fragmented, one-off verification systems with a universal, chain-native registry for attestations. It gives developers a way to issue and consume claims that are trustworthy, reusable, and easy to build with. From KYC and Sybil protection to AI coordination and credit scoring, Verax serves as the shared trust layer for Web3.
In a decentralized internet where applications, agents, and users need to prove things without relying on centralized control, Verax offers a simple answer: let the data speak—on-chain, in public, and in a format anyone can trust.