A validium is a zero-knowledge scaling solution that processes transactions off-chain, posts a validity proof to Ethereum, and — critically — stores the transaction data off-chain instead of on the main chain. It is the answer to the question: "what if we kept the cryptographic security of a zk rollup, but stopped paying Ethereum to hold all the data?"
The one-sentence version: a validium gives you the fast, cheap, private throughput of an L2 while Ethereum still cryptographically verifies every batch — the tradeoff being that a committee holds the off-chain data, and you must trust that committee not to withhold it.
If you have used a gas-free NFT marketplace, traded perpetual futures at a fraction of the L1 cost, or wondered validium vs rollup — which scaling model actually powers these apps — this article answers it. We'll cover what a validium is, how it works, the validium vs rollup difference in plain terms, the off chain data zk mechanics that make it work, and when each solution is the right choice.
Figure 1: The Core Idea — the proof goes on-chain, the data stays off-chain
The Two Jobs a Scaling Chain Must Do
Before validium makes sense, separate the two things any rollup must handle:
- Prove the math is right. Every batch of transactions must be cryptographically proven to follow the rules — balances change correctly, no one creates money from nothing. A zk rollup does this with a validity proof (ZK-SNARK or ZK-STARK).
- Make the data available. Someone must be able to reconstruct the state — see who owns what — so users can withdraw funds and the chain can be audited. In a rollup, this data is published on Ethereum.
The crucial insight: proof and data are two different guarantees. The proof says "this state transition is valid." The data says "here is what the state actually is, and anyone can read it." A validium keeps the proof and moves the data.
What a Validium Actually Is
A validium is a Layer 2 solution where:
- Transactions are executed off-chain by an operator (a single sequencer or a proof-of-stake rotation of operators).
- The operator batches transactions, computes the new state, and generates a validity proof (ZK-SNARK or ZK-STARK).
- The proof — plus a single hash of the ledger data — is posted to Ethereum.
- The full transaction data lives off-chain, stored by a Data Availability Committee (DAC): a quorum of independent, reputable entities (StarkEx's default committee has included ConsenSys, Infura, Nethermind, Cephalopod, Iqlusion, and StarkWare).
Ethereum's on-chain verifier contract checks the proof. If the proof is invalid, the batch is rejected — the state cannot be updated with bad math. This is the same cryptographic guarantee as a zk rollup.
The difference is entirely about where the data lives.
How a Validium Works, Step by Step
- User submits a transaction to the validium operator (e.g., an exchange's order engine).
- Operator batches transactions off-chain and computes the new state (who owns what after all orders, trades, or mints).
- Operator generates a ZK proof that the state transition is valid.
- The proof + a hash are posted to Ethereum. The on-chain verifier confirms the proof. If valid, the new state root is accepted.
- The full transaction data goes to the DAC off-chain, where it is stored and attested to.
Withdrawal: because your funds are controlled by a smart contract on Ethereum, you can withdraw by providing a Merkle proof that your withdrawal is included in a verified batch — plus, in validium mode, an attestation (signature) from a DAC member. This makes withdrawals near-instant compared to rollups.
Validium vs Rollup: One Difference, Big Consequences
| ZK Rollup | Validium | |
|---|---|---|
| Data availability | On-chain (Ethereum L1) | Off-chain (DAC / DA network) |
| Validity proof | ZK-SNARK / ZK-STARK | ZK-SNARK / ZK-STARK |
| On-chain storage | Proof + full transaction data | Proof + a hash only |
| Cost per transaction | ~$0.10–$0.50 (data dominates gas) | <$0.01 |
| Throughput | 2,000+ TPS theoretical | 9,000+ TPS theoretical |
| Withdrawal time | ~10–30 minutes | Near-instant (committee attestation) |
| Self-custody | Unconditional — anyone can reconstruct state | Conditional — depends on DAC providing data |
| Privacy | Transactions public on Ethereum | Balances/transactions hidden off-chain |
| Use cases | High-value DeFi, custody | Gaming, NFTs, high-frequency low-value trading |
Two consequences follow from this one difference:
- Cost and speed. In a rollup, most of the gas cost goes to publishing data, not verifying the proof. Move the data off-chain and the cost floor collapses — which is why validium apps like Immutable X offer gas-free NFT minting and 9,000+ TPS.
- A new trust assumption. In a rollup, anyone can reconstruct the state from Ethereum and withdraw their funds — no external party required. In a validium, users must trust the DAC to keep and release the data. If the committee withholds the data, users cannot compute the Merkle proof needed to withdraw — funds can be frozen.
That second point is the heart of the validium vs rollup choice: validium trades a bit of trustlessness for a lot of cost and speed.
Figure 2: Validium vs Rollup — the only difference is where the data lives
Why "Off Chain Data ZK" Is the Secret Sauce
The phrase off chain data zk captures the entire mechanism: zero-knowledge proofs make off-chain data safe. Here's why it works:
- The proof guarantees that the state transition the data describes is mathematically correct — even though the data never touches Ethereum.
- The hash on-chain commits to the state, so the operator cannot later claim a different state than the one proven.
- Only the availability of the data is delegated to the DAC — not its validity.
A useful mental model: the proof is the accountant's certified stamp ("the books balance, verified"); the data is the ledger itself ("these are the actual entries"). The stamp is public and checked by Ethereum; the ledger sits in a secure warehouse that trusted parties watch over.
The Confidentiality Bonus
Because the data is off-chain, a validium gets a privacy bonus for free: balances and transactions are not visible to anyone scanning Ethereum. In rollup mode, every account balance is public at every proof. In validium mode, only the DAC sees the ledger.
This matters for real products — trading firms don't want their order flow public, and NFT/gaming apps don't need every mint broadcast to the world. The "off chain data zk" design hides the details while the proof keeps everything verifiable. It's a genuinely different value proposition from rollups, not just a cheaper one.
Volition: The Hybrid That Lets You Choose
StarkWare's Volition architecture makes the tradeoff a per-transaction choice. In a Volition, users can choose for each transaction:
- Rollup mode — data goes on-chain. Costs more, but unconditional self-custody.
- Validium mode — data stays off-chain. Cheaper, but relies on the DAC.
The canonical example: you buy an expensive NFT (like a Bored Ape) → use Rollup mode so a permanent public record is on Ethereum. You buy a cheap in-game item → use Validium mode to save fees. One app, one ledger system, per-transaction control of the security/cost dial.
Figure 3: Volition — choose rollup or validium mode per transaction
The Honest Tradeoff
When a validium is the right call:
- High-frequency, low-value transactions where fees dominate: DEX trading (dYdX v3 ran on StarkEx validium), NFT minting and trading (Immutable X, Sorare), gaming assets.
- Applications that want transaction privacy by default.
- Products where near-instant withdrawals and 9,000+ TPS matter more than unconditional self-custody.
When a rollup is the right call:
- High-value DeFi: lending, custody, anything where "everything you own" must be withdrawable under any circumstances, with no trusted party.
- Permissionless, credibly-neutral infrastructure where a committee is unacceptable.
The honest summary: a validium is not "rollup but cheaper" — it is a different risk profile. The math is equally proven; the data availability is delegated. For payments, games, and trading, that delegation is a great deal. For "this is my entire savings," it is the wrong tool.
Common Questions About Validium
What is a validium in simple terms?
A Layer 2 that processes transactions off-chain, sends a ZK validity proof to Ethereum, and stores the transaction data off-chain with a trusted committee instead of on Ethereum.Validium vs rollup: what's the main difference?
Where the data lives. Rollups publish transaction data on Ethereum; validiums keep it off-chain with a Data Availability Committee. Rollups are more trustless; validiums are much cheaper and faster.How does "off chain data zk" make validium secure?
The ZK proof cryptographically verifies the state transition even though the data is off-chain, and a hash commits the state on-chain. Only data availability — not validity — is delegated to the committee.What happens if the validium's data committee fails?
If the DAC withholds or loses the data, users cannot compute the Merkle proofs needed to withdraw — funds can be frozen. This is the core risk of validium, and why high-value assets usually stay on rollups.Which real products use validium?
StarkEx-powered apps: dYdX v3 (perpetual DEX), Immutable X (NFT/gaming, 9,000+ TPS, gas-free minting), Sorare (fantasy-sports NFTs), and DeversiFi. zkSync's zkPorter and Immutable zkEVM also use validium-style off-chain data.Is a validium a zk-rollup?
No — but it uses the same validity-proof technology. A zk-rollup keeps data on-chain; a validium keeps it off-chain. Both are verified by ZK proofs on Ethereum; the difference is data availability.How do users withdraw from a validium?
By submitting a Merkle proof that their withdrawal is in a verified batch, plus a committee attestation in validium mode. Withdrawals are near-instant compared to rollups.What is Volition?
StarkWare's hybrid architecture that lets users choose per-transaction between rollup mode (data on-chain) and validium mode (data off-chain).The Bottom Line
A validium is the answer to a specific question: how do we keep ZK validity without paying for on-chain data? By moving data off-chain to a trusted committee, validiums unlock the throughput and cost profile that real products need — gas-free NFTs, 9,000+ TPS DEXs, and private-by-default ledgers — while Ethereum still verifies every batch cryptographically.
The tradeoff is real and should be respected: validium vs rollup is a data-availability decision, not a quality ranking. Choose a validium when cost, speed, and privacy matter more than unconditional self-custody. Choose a rollup when the assets are too valuable to entrust to any committee. Knowing which is which — and understanding the off chain data zk mechanism underneath — is the difference between choosing a scaling tool and choosing the wrong one for your funds.
Quick Reference
| Property | Validium |
|---|---|
| What it is | L2 with ZK validity proof + off-chain data availability |
| Validity proof | ZK-SNARK or ZK-STARK, verified on Ethereum |
| Data location | Off-chain with a Data Availability Committee (DAC) |
| On-chain storage | Proof + single hash of the ledger |
| Cost | <$0.01 per tx; often gas-free (Immutable X) |
| Throughput | 9,000+ TPS theoretical |
| Withdrawal | Merkle proof + committee attestation, near-instant |
| Main risk | Data withholding → funds frozen |
| Privacy | Balances/transactions hidden from public blockchain |
| Hybrid option | Volition: per-transaction rollup vs validium choice |
| Production examples | dYdX v3, Immutable X, Sorare, zkPorter, Immutable zkEVM |