Zauth is a privacy-first human verification system built with Noir circuits, Barretenberg proving, and zkVerify verification. It is designed to let applications prove that a user passed a CAPTCHA-style challenge without exposing the underlying private inputs or turning the result into a reusable identity primitive.
Zauth is building a lightweight proof-of-human-interaction layer for modern apps. The goal is to replace traditional CAPTCHA flows with a zero-knowledge flow where a frontend challenge is solved once, transformed into a proof, and then verified through zkVerify so the application can trust the result without learning sensitive user-side data.
At a product level, Zauth focuses on three things:
- Reducing bot and scripted abuse.
- Preserving user privacy during verification.
- Making verification portable for apps that want stronger guarantees than a normal CAPTCHA response token.
zkVerify is a dedicated blockchain for zero-knowledge proof verification, built to verify proofs efficiently instead of treating proof verification as a side task inside a general-purpose chain. Its workflow is built around submitting a proof, verifying it on zkVerify, and then using an aggregation or attestation flow so external applications can confirm the result.
That matters for Zauth because proof verification is the expensive and integration-sensitive part of a ZK application. By building on zkVerify, Zauth can focus on generating the right proof for its human-verification flow while relying on zkVerify as the verification and attestation layer.
Zauth uses Noir for circuit logic and Barretenberg for UltraHonk proof generation. zkVerify’s UltraHonk verifier is designed for proofs generated with Barretenberg, and zkVerify’s proof-generation docs explicitly cover Noir and UltraHonk as a supported path.
A high-level flow looks like this:
- A user solves a frontend challenge.
- The app encodes the challenge result into circuit inputs.
- A Noir circuit proves the expected condition without revealing private values.
- Barretenberg generates an UltraHonk proof and verification key.
- Zauth submits the proof to zkVerify for verification.
- The application consumes the verified result for gating, anti-bot protection, or downstream authorization.
Traditional CAPTCHA systems usually ask users to trust a centralized verifier and leak more application metadata than needed. Zauth moves that flow toward verifiable privacy, where the app only needs to know that the required challenge was satisfied and that the proof was verified correctly.
This approach is useful for:
- Sign-up and login protection.
- Rate-limit bypass for verified humans.
- Sybil-resistance layers in consumer apps.
- Bot mitigation for forms, mints, communities, and lightweight onchain experiences.
Zauth is currently aligned with zkVerify’s Noir and UltraHonk path. zkVerify documents UltraHonk as a supported verifier generated through Barretenberg, and describes proof verification as part of a broader flow that can later feed attestations and external settlement logic.
That makes Zauth a good fit for the ecosystem because it represents a practical consumer-facing use case: human verification that is private, composable, and cheap enough to integrate into real products.
The project is focused on making the proving and verification pipeline reliable end-to-end: Noir circuit execution, UltraHonk proof generation, zkVerify submission, and application-side result handling. The immediate technical goal is to make proof artifacts, public inputs, and zkVerify submission semantics fully consistent so the verification flow can be used as a clean developer-facing primitive.
Zauth aims to become a reusable privacy-preserving verification module for teams that want bot resistance without sacrificing user privacy. In the long run, the same pattern can extend beyond CAPTCHA replacement into broader proof-based access control, reputation gating, and verified user actions across apps that need trust without data exposure.