What is Verax Attestation Registry?

Introduction

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.

What is Verax?

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.

Core Building Blocks

Verax is designed with five components that work together to support the full lifecycle of attestations.

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

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

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

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.

Registry and Subgraph

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.

How Verax Works

Define a Schema

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.

Deploy a Portal

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.

Issue the Attestation

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.

Verify and Consume

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.

Shared Attestations Across dApps

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.

Supported Networks and Architectural Benefits

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.

Key Use Cases and Integrations

Verax is already supporting critical use cases across identity, automation, and token access.

Sumsub and Linea: On-Chain KYC

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’s Proof of Machinehood

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: Fair Token Distribution Across Networks

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.

Why Builders Are Adopting Verax

Verax simplifies verification and unlocks new capabilities for Web3 developers.

Faster Development, Lower Costs

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.

Portable Identity and Reputation

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.

Trust Infrastructure for AI and DePIN

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.

Governance and Neutrality

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.

Developer Quick Start Guide

Verax offers a fast path to integration.

1. Register a schema via the Verax contract or SDK
2. Create a portal (optional) to control who can issue under that schema
3. Issue attestations with Verax SDKs in JavaScript or TypeScript
4. Query and verify via the Verax subgraph and use in your dApp logic

Example contracts, templates, and developer tools are available on GitHub. Most teams can issue and verify attestations in under an hour.

Vision and Future Outlook

Verax is becoming the default attestation layer for EVM chains, but its roadmap is broader.

1. Cross-chain attestations will allow a claim issued on Linea to be verified on Base or Optimism.
2. Zero-knowledge privacy modules will enable selective disclosure for sensitive data.
3. Linked-data schemas will support complex, composable claims across apps.
4. Agent and machine memory will give AI-driven dApps a secure way to prove past actions.

Conclusion

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.