What Is zkTLS? Web Proofs Explained

Blockchains are excellent at verifying what happens on-chain and nearly blind to everything else. zkTLS, a family of protocols also called web proofs, lets anyone prove facts from an ordinary HTTPS session, a bank balance, a driver rating, a loyalty tier, without revealing the underlying data or asking the website for permission. Here is how it works, who is building it, and where the trust assumptions hide.

Crypto has a data problem that predates every bull market narrative. Smart contracts can verify a token transfer with mathematical certainty, but they cannot see a payroll deposit, a university diploma, an Uber rating, or a frequent flyer tier. All of that information lives behind the login walls of Web2 platforms, reachable only through official APIs that are limited, revocable, and priced at whatever the platform decides. Oracles solved a narrow slice of this, mostly public price feeds, and were never designed to carry personal data.

zkTLS is the attempt to solve the rest of it. The idea is simple to state and hard to engineer: take the secure connection your browser already makes to any website, and turn what you see in that session into a cryptographic proof that anyone can verify, without exposing your password, your session, or the raw data itself. If it works at scale, every piece of information behind every login on the internet becomes portable, provable, and usable on-chain.

Start with TLS

Every website address that begins with https uses Transport Layer Security, or TLS. It is the protocol that secures roughly 95% of web traffic. When your browser connects to your bank, TLS performs a cryptographic handshake that does three things: it confirms you are talking to the real server, it encrypts the traffic so nobody in the middle can read it, and it guarantees the data was not altered in transit.

What TLS does not do is produce evidence. The encryption is symmetric, meaning your browser and the server share the same session keys. Once the session ends, you have no way to prove to a third party what the server sent you. You could screenshot your bank balance, but screenshots are trivially forged. You could hand over your login, but that exposes everything. You could share the session keys, but since the same keys both encrypt and authenticate, whoever holds them could fabricate any transcript they like. TLS was built for private communication, not for portable proof. That gap is what zkTLS fills.

What zkTLS actually is

zkTLS, short for zero-knowledge Transport Layer Security, is an umbrella term for protocols that make TLS sessions verifiable. The core output is a proof with two properties. Authenticity: the data genuinely came from a specific domain during a real TLS session, unaltered. Selectivity: the proof reveals only the specific claim being made, such as balance above $5,000 or rating above 4.8, while everything else in the session, including credentials, stays hidden.

One naming caveat worth knowing: the term is a misnomer. Not every implementation uses zero-knowledge proofs, and the emphasis is often verifiability first, privacy second. Many builders prefer the terms web proofs or TLS attestations. The industry has mostly settled on zkTLS anyway, so this guide uses it while flagging the imprecision.

The hard engineering problem is that TLS was never designed to admit a third-party verifier. Three architectures compete to solve it, each with different trust assumptions.

The three models

MPC-TLS. The oldest approach, pioneered by the nonprofit TLSNotary project, which dates back to 2013. Secure multi-party computation splits the TLS session keys between the user and a verifier node, so neither party ever holds the full keys. The verifier participates in the encrypted session cryptographically, using techniques like garbled circuits, and can attest to what the server sent without seeing the plaintext or being able to forge it. The security is the strongest of the three models, and the cost is overhead: MPC adds heavy network round-trips, which historically made proofs slow. Opacity Network builds on this model and has pushed hard on decentralizing the verifier set. Research directions like vector oblivious linear evaluation could cut MPC networking costs enough for one-second proofs.

Proxy witness. A proxy sits between the user and the website, forwarding the encrypted traffic and attesting that the recorded exchange really happened between that client and that domain. The user then proves claims about the decrypted contents, often with a zero-knowledge proof. This is the fastest model in production. Reclaim Protocol, its leading implementer, generates proofs from a phone in about two to four seconds with no app or extension, supports most major blockchains, and lists 889 community-built data sources. An academic paper titled Proxying is Enough put the probability of breaking Reclaim’s construction at ten to the power of minus forty. The trade-off is a trust shift toward the proxy layer and practical friction, since some platforms firewall known proxy traffic, which Reclaim works around with residential proxies.

TEE-based. Trusted execution environments, the tamper-resistant enclaves inside modern processors, handle the session inside sealed hardware. The enclave logs in, fetches the data, and signs an attestation about what it saw, with minimal performance overhead. The trust assumption moves to the chip: you are trusting the hardware manufacturer and the enclave’s resistance to side-channel attacks, a category with a documented history of breaks. zkPass began as an MPC project and now runs a hybrid, using a proxy witness model in production with MPC as backup, while other teams lean on TEEs for speed.

No model is strictly best. MPC maximizes cryptographic trust and pays in latency, proxies maximize speed and pay in trust assumptions, TEEs maximize convenience and pay in hardware dependence. Serious applications pick based on what breaks their use case first.

A worked example, start to finish

Abstractions aside, here is what a zkTLS flow looks like in practice for one concrete case: a borrower proving to a lending protocol that their bank balance exceeds $5,000, without sharing statements or credentials.

The borrower opens the lender’s app, which hands off to a zkTLS client, typically a lightweight mobile flow with no separate install. The client opens a normal TLS session with the bank’s website, and the borrower logs in exactly as they always do. Their password travels over the same encrypted channel as any ordinary login; the verifier never sees it, because depending on the model, the verifier either holds only a useless share of the session keys, or observes only ciphertext passing through a proxy.

The bank’s server returns the account page, oblivious to anything unusual. From its perspective, this is a routine customer session. The client then isolates the relevant response data, the balance field, and generates a proof of a narrow statement: this TLS session was with the bank’s real domain, the response was not altered, and the balance value in it exceeds $5,000. The actual number stays hidden. The account history stays hidden. The login stays hidden.

The proof lands on-chain or with the lender’s backend, where a verifier contract checks it in milliseconds. The whole round trip takes seconds on the proxy model, and the lender has learned exactly one bit of information: qualified. Compare that against the incumbent process, which involves uploading full statements to a stranger’s server and trusting their retention policy forever, and the appeal writes itself. The same skeleton, swap the bank for any website and the balance for any visible fact, is every zkTLS application in existence.

From 2013 curiosity to 2026 infrastructure

The idea is older than most of the industry using it. TLSNotary shipped its first construction in 2013, before Ethereum existed, as a way to notarize web pages for dispute resolution. For a decade it stayed a cryptographic curiosity: the MPC overhead made proofs slow, the tooling assumed expertise, and crypto had no application layer hungry for private off-chain data.

Three things changed. Zero-knowledge proving systems got fast and cheap on the back of the rollup boom, which industrialized zk engineering talent and libraries. Mobile-first implementations, led by Reclaim’s proxy design, collapsed proof generation from minutes on a desktop to seconds on a phone. And the application layer arrived: identity networks, points programs plagued by sybils, prediction markets processing tens of billions monthly, and AI agents that need to verify what they pay for. By the time Devconnect dedicated a full day to the technology, the question had shifted from whether web proofs work to which trust model wins each vertical.

What people are building with it

The use cases sort into a few families, and most of them were impossible before.

• Proof of personhood and identity. Humanity Protocol, the Worldcoin rival valued at $1.1 billion after a round co-led by Jump Crypto and Pantera, launched its mainnet with zkTLS at the center. Users link Web2 accounts, from airline loyalty programs to professional profiles, to a portable Human ID, proving who they are and what they have achieved without any central party seeing the underlying documents. It is identity verification without iris scans.
• Credit and undercollateralized lending. DeFi lending is overcollateralized because protocols cannot see income. With zkTLS, a borrower proves salary deposits, bank balances, or an off-chain credit score directly from the source, without handing over statements. Projects like Cr3dentials build income and KYC verification for lenders on this rail, and lending protocols use web proofs to unlock on-chain credit against Web2 financial reputation.
• Reputation portability. Opacity’s early demo let Uber drivers export their ratings to a rival platform. The same pattern applies to seller ratings, subscriber counts, and gaming achievements: reputations that platforms hold hostage become assets the user carries. This is the quietly radical part, because data lock-in is the moat under most large internet businesses.
• Marketplaces for gated goods. zkP2P uses web proofs to power a ticket marketplace where a seller proves they own a real ticket inside the vendor’s own system before the trade settles, collapsing the fraud problem that plagues secondary markets.
• Data for markets and AI agents. Prediction markets need trustworthy real-world data, and resolution disputes remain the sector’s biggest weakness. Web proofs offer a way to verify a source document cryptographically instead of arguing about it. The same applies to AI agents that buy data over protocols like x402: projects like MCPay use zkTLS to prove that an API response an agent paid for is authentic and untampered.

Why the timing is 2026

The technology is a decade old in concept, so the fair question is why it matters now. Three currents converged.

First, privacy became the sector’s active narrative. A16z crypto argued that privacy is the moat of crypto’s next phase, a thesis that has pulled privacy coins and privacy infrastructure back into focus. zkTLS is the consumer-facing end of that stack: it lets users prove things about themselves while revealing less, the exact inversion of how the data economy currently works.

Second, the tooling matured. Reclaim’s mobile-speed proofs, TLSNotary’s open-source verifier infrastructure, vlayer’s web proofs for Ethereum developers, and zkPass’s production deployments moved the field from papers to SDKs. Ethereum’s Devconnect conference now runs a dedicated zkTLS Day, with hands-on workshops across the competing implementations, a reliable sign that a primitive has crossed from research to developer adoption.

Third, adjacent security work made verifiable data legible to a mainstream audience. Ethereum’s push to end blind transaction approvals through the ERC-7730 Clear Signing standard trained the industry to ask what users can actually verify on their screens. zkTLS asks the same question about data instead of transactions.

How this differs from oracles, and why both survive

Because zkTLS moves off-chain data on-chain, it gets lumped in with oracle networks, and the comparison is worth drawing precisely. Chainlink, Pyth, and their peers are push systems: node networks fetch public data, mostly prices, aggregate it, and publish it continuously for every application to read. The economics amortize across all users of a feed, and the security model rests on the independence and stake of the node operators. This design is close to unbeatable for its job, which is why DeFi’s core money legos still run on it.

It also cannot do what web proofs do. An oracle network has no mechanism for data that requires logging in as a specific person, and no economics for data only one user will ever need. Nobody runs a Chainlink feed for your bank balance. zkTLS inverts every design choice: pull instead of push, per-user instead of shared, private data instead of public, generated on demand instead of streamed. The user is the oracle, and cryptography replaces the node network as the reason to believe them.

The mature stack will use both. Public market data flows through feed networks; personal, session-gated facts flow through web proofs; and the two already meet in places like prediction market resolution, where a price feed settles the objective markets and a verified source document could someday settle the contested ones.

The limits and the risks

An honest account has to include the ways this can disappoint.

Trust assumptions never disappear, they relocate. The proxy model trusts the witness layer not to collude with the user. The TEE model trusts silicon vendors. Even MPC, the most trust-minimized, typically relies on a verifier network whose decentralization is a work in progress. When a marketing page says trustless, the correct response is to ask which of the three models it runs and what breaks it.

Websites are not passive. Platforms change page structures constantly, which breaks data source integrations, and some actively resist automated access. A protocol whose data sources depend on scrapers dressed in cryptography inherits the fragility of scrapers.

Privacy cuts both ways. The same machinery that lets a user prove facts without exposure can help bad actors move value while revealing less to investigators. Wallet drainers adopting privacy tooling is not hypothetical, and regulatory attention on privacy-preserving infrastructure has a long track record.

And selective disclosure invites coercion. If proving your salary to a landlord becomes possible, it can become expected. A technology built to minimize disclosure can normalize new categories of demanded proof. That is a social risk, not a cryptographic one, and no protocol upgrade fixes it.

The quiet stakes: what happens to data moats

Zoom out from the cryptography and zkTLS is an economic weapon aimed at the deepest moat on the internet. Large platforms defend their positions with data lock-in: your ratings, your history, your follower graph, and your purchase record live on their servers, and leaving means starting from zero. That switching cost is why a five-star driver stays on one app, why a power seller cannot move marketplaces, and why challenger platforms die in the cold-start phase regardless of how good their product is.

Web proofs dissolve the lock without asking the incumbent’s permission. If a new ride platform can accept a cryptographic proof of a competitor’s rating, it inherits the trust the incumbent spent a decade accumulating, and the user carries their reputation the way they carry a passport. A lender can underwrite against a credit history it never stores. A social network can import proof of an audience without an API deal that the incumbent can revoke on a whim, which incumbents historically do the moment a client grows threatening.

Incumbents will not stay passive, and the countermeasure escalation is predictable: aggressive bot detection, page structures that shift weekly, legal pressure on proxy infrastructure, and terms of service amended to prohibit proof generation. None of those measures can break the cryptography, but all of them can raise the maintenance cost of data source integrations, and the protocols that win will be the ones that industrialize that maintenance. The fight over whether users own the facts about themselves is about to move from privacy policy debates into engineering, and for once the users’ side has tooling.

The bridge crypto kept promising

For years the industry described blockchains as a trust layer for the internet while the internet’s actual data sat somewhere the chains could not reach. zkTLS is the most credible attempt yet to close that gap without asking platforms for permission, and permissionlessness is the whole point: no API deal, no data-sharing agreement, no gatekeeper deciding which facts are exportable. Whether it becomes core infrastructure depends on the unglamorous work ahead, decentralizing verifier networks, surviving platform countermeasures, and proving the trust models under adversarial pressure. The primitive, though, is real, the proofs verify, and the fortress walls around Web2 data have their first practical siege engine.

Frequently asked questions

Disclaimer: This article is for informational purposes only and does not constitute investment advice. Digital asset markets are volatile and you can lose your entire investment. Always do your own research. Information current as of July 3, 2026.