DeFi lending still has a basic problem.

Most of it runs on overcollateralization. Want to borrow? You usually lock up more than you're taking out. That keeps protocols safe, but it also makes capital inefficient and leaves out a huge number of people who are creditworthy in the real world but have no way to prove it onchain. Billions in capital stay underused, while real users get excluded because their credibility lives offchain.

And that credibility does exist.

It sits in exchange accounts, payment histories, and the online identities people have built over time. The issue has never been whether the data is there. It’s how to use it without forcing people to give up privacy or rely on unverifiable claims. That tradeoff has held this back for years.

ZKredit is part of a broader push to remove that tradeoff.

What is ZKredit?

ZKredit is a privacy-preserving identity verification middleware built on BNB Chain, co-built with Brevis and Primus. It lets people prove facts about their real-world accounts without exposing raw personal data, and records those verified data points onchain so any application can use them.

It isn’t trying to be a lender, a scoring platform, or a centralized identity gatekeeper. It’s infrastructure. Neutral infrastructure that verifies facts and makes them available onchain in a way that’s composable across the ecosystem.

It also sits within a broader identity framework being developed on BNB Chain, where different parts of the stack handle data verification, private computation, and how that data becomes usable across applications.

The credit logic comes later, and it belongs to the applications building on top.

Built on ZKTLS, with privacy by design

Under the hood, ZKredit uses ZKTLS (Zero-Knowledge TLS) to generate cryptographic proofs directly on the user’s device, with Primus handling data capture from Web2 platforms and Brevis enabling private computation on that data.

The original data never leaves the user. Only the proof goes onchain.

That design choice is the whole point.

Raw data isn’t uploaded to a server, stored onchain, or passed between intermediaries. What gets submitted is a proof that a claim is true, giving protocols something they can verify without asking users to expose everything behind it.

But proving the data is real is only part of the problem.

What actually matters is being able to use that data.

Once captured, that data can be processed through private computation so that specific conditions can be proven without revealing the inputs. Whether it’s checking account age, balance thresholds, or activity patterns, the result is a clean, verifiable signal that applications can use without ever seeing the underlying data.

How it Works

The flow is simple.

A user logs into a Web2 platform like a centralized exchange, GitHub, Amazon, or another supported platform. The ZKredit Prover, which runs as a browser extension, captures and proves that data locally on the user’s device.

From there, the data is processed into a verifiable result, and that result gets submitted to BNB Chain, where the ZKredit Registry stores it as an onchain attestation.

From that point on, applications can query those verified facts and apply their own logic.

ZKredit doesn’t decide what a verified trading history should mean, or whether a contribution record should unlock better borrowing terms. It simply makes verified facts available in a tamper-proof way, and leaves the interpretation to the applications building on top.

Behind the scenes, this runs as a layered system

What looks simple from the outside is handled across different parts of the stack.

First, data needs to be captured and proven authentic. That happens through zkTLS, where a user logs into a platform and the data is verified at the source without leaving their device.

Then that data needs to be made usable. Instead of exposing raw information, it gets processed through private computation, which produces a proof that a specific condition is true.

Finally, that result is recorded onchain as an attestation, where it becomes something applications can query and build on.

Each part solves a different problem. Together, they make the system usable.

The 3 core components

ZKredit is made up of three main pieces:

• ZKredit Prover: A browser extension that guides users through authorization and generates proofs locally. Raw data never leaves the device.
• ZKredit Registry: A smart contract layer on BNB Chain that stores verified data points as a neutral, tamper-proof record.
• ZKredit Console: An admin interface used to configure supported platforms, data fields, verification rules, and third-party access permissions.

Taken together, these components create a system that works from both sides. It’s simple enough for users to verify data privately, and structured enough for builders to configure and integrate into real products.

What makes ZKredit different

Three things set ZKredit apart:

1. Privacy by design - Raw data is never uploaded or stored. Only cryptographic proofs are submitted.
2. Neutral infrastructure - ZKredit doesn’t compute credit scores or make subjective decisions. It records verified facts, and applications decide how to use them.
3. Identity binding that actually means something - Each Web2 account can only be bound to one wallet globally, with a cooldown before rebinding. That makes it significantly harder to game the system and keeps the data meaningful across protocols.

Because a credit identity layer only works if it’s difficult to manipulate. If accounts can be recycled across wallets, the signal breaks down.

Built for composability

One of the strongest parts of the design is how easy it is to use once it’s live.

Any protocol on BNB Chain can query the onchain registry through a single interface call, without building custom data pipelines or relying on external providers.

Once a user proves something, that attestation doesn’t live inside a single application. It becomes reusable across any application that integrates with the same identity layer.

That means you don’t have to prove the same thing repeatedly across different protocols. The proof exists once, and can be used wherever it’s needed.

Instead of every protocol solving identity on its own, there’s now a shared layer that others can build on.

What ZKredit Unlocks

ZKredit changes how you can think about users at a protocol level.

Instead of treating every wallet the same, you can start working with verified signals like account history or activity, giving you a more grounded way to differentiate between users.

In lending, that could mean verifying that a user meets certain thresholds or has maintained activity over time, without exposing any of the underlying data. The protocol gets a clear signal, and the user keeps their privacy.

From there, it extends further. Access models can change. Products can respond to real usage patterns. Reputation can start to play a role alongside balances.

Built for BNB Chain

ZKredit runs in an environment where this kind of system is actually usable.

Low fees make verification practical. High throughput allows it to scale. And the existing DeFi ecosystem gives these verified signals somewhere to be used immediately.

It also means different parts of the stack can evolve together, from how data is captured, to how it’s computed, to how applications use it onchain.

Because identity only becomes useful when it fits into real workflows.

A new building block for onchain credit

Until now, most identity systems in Web3 have been built in isolation. What’s changing here is the move toward a shared approach, where identity doesn’t fragment across applications but compounds across the ecosystem.

ZKredit is one piece of that foundation.

It gives you a way to prove real-world facts without exposing personal data, makes those verified facts available through a neutral onchain registry, and creates a shared identity layer that protocols can build on.

Because DeFi doesn’t just need more liquidity. It needs better context and this is how that starts to take shape.