A privacy-preserving identity, credential, and verifiable data platform for organizations that can’t afford to get trust wrong.

Zakapi lets people and organizations check important facts without sending around full documents or exposing all their data.

Instead of sharing everything, you share:a simple answer (yes / no / small piece of info) plus a proof that the answer is correct.

Problem Today: To open an account, prove who you are, or use many online services, you are often asked to:

- Upload ID photos

- Share bank statements or utility bills

- Email PDF documents

- Fill in the same details again and again

This leads to:

- Too many copies of sensitive data

- High risk if any system is hacked

- Slow, painful onboarding for users and businesses

What Zakapi Does: Zakapi turns these document-heavy checks into questions with proof.

A service can ask things like:

- Is this person over 18?

- Is this ID valid and not revoked?

- Has this customer passed KYC in the last 12 months?

- Is this licence or policy still active?

Zakapi returns:

- The answer

- A proof that the answer was calculated correctly from trusted data

The proof can be checked, but it does not reveal your full records.

Zakapi’s model has three simple roles.

ISSUER – the source of truth/ Organizations that hold official records, such as:

- Governments and public authorities

- Banks and fintechs

- Telecom operators

- Universities and professional bodies

- Insurers and regulator

They issue digital credentials like:

- This is your ID

- You passed KYC

- You are a licensed professional

- Your policy is active

HOLDER – the person or company

- Keeps these credentials in a secure Zakapi-powered wallet (mobile or web)

- Chooses what to prove and to whom

- Sees a history of where and when proofs were shared

VERIFIER – the one who needs to know

- A bank, app, employer, marketplace, healthcare provider, or public service

- Asks clear questions such as “Is X true?”

- Receives answers backed by proofs, not raw documents

Zakapi connects issuers, holders, and verifiers

so everyone gets only what they actually need.

How It Feels in Real Life

Today: Upload your ID, a selfie, proof of address, and several PDFs.

We will review them and get back to you.

With Zakapi: Please prove you are over 18 and have passed KYC in the last 12 months.

Your Zakapi wallet:

- Uses your existing credentials from trusted issuers

- Sends back a yes/no answer or a small piece of data (for example, country = X)

- Attaches a proof that this is correct and up to date

The service never sees your full ID photo, full address, or bank history.

It only sees what it needs to make a decision.

Where Zakapi Helps Most: Zakapi is designed for situations where trust, privacy, and compliance matter:

- Digital identity – proving who you are without oversharing

- Banking and fintech – faster KYC and AML with less data stored

- Telecom – secure SIM and eSIM registration and age checks

- Healthcare – proving coverage or eligibility without exposing records

- Education and work – proving diplomas, licences, and certifications

- Public services – checking eligibility with minimal data sharing

Anywhere people send around sensitive documents today,

Zakapi aims to replace that with short answers plus strong proofs.

Zakapi lets you know what you need to know, prove it is true, and keep everything else private.

Share Proofs, Not Data

Privacy-Preserving Identity & Verifiable Data for a Secure Digital World

Zakapi lets people prove anything about themselves—age, identity, qualifications, rights—without sharing unnecessary private data. At the same time, it lets institutions run SQL-style checks over their own sensitive databases and get cryptographic assurances that the right query was run on the right data and computed correctly—without exposing underlying records.

Governments and enterprises get answers they trust, backed by non-interactive proofs that any supporting database queries were executed correctly on authenticated, up-to-date datasets. Individuals keep their personal information safe.

What is ZAKAPI?

Zakapi is a Zero-Knowledge Identity, Credential & Verifiable Data Platform for government agencies, regulated businesses, and critical infrastructure providers.

We turn every sensitive question into a cryptographic proof instead of a data dump. Organizations can:

• Validate attributes (age, citizenship, eligibility, KYC status, etc.), and
• Run SQL-style policies over the datasets they control,

all via non-interactive zero-knowledge proofs built on PoneglyphDB-style techniques (PLONKish circuits with custom SQL gates and polynomial commitments). The user’s data stays under their control or inside protected databases; the verifier gets a mathematically verified “yes/no” or “meets criteria” answer with a reusable proof.

Example: A youth sports platform needs to verify players are under 18 and ensure the check is done against the latest registration data. With Zakapi, a guardian proves “child’s age < 18” via a digital credential—without revealing the exact birthdate—while the league gets a non-interactive proof that the age rule was evaluated on the committed, up-to-date roster database. Compliance is satisfied; the family’s privacy stays intact.

Why ZAKAPI?

❖ Privacy First

Built from the ground up on privacy-enhancing technologies like zero-knowledge proofs. When a proof is enough, we never expose or collect raw personal data or bulk database exports. Every design follows “share the minimum necessary” and “consent by design,” at both the wallet layer and the verifiable-SQL layer.

❖ End-to-End Security

Identity credentials are digitally signed and verifiable without contacting a central server. Non-interactive ZK proofs ensure verifications cannot be forged and are bound to cryptographic commitments of the underlying databases, so any verifier or auditor can later check correctness from logs—no need to be online during execution. The platform is built in Rust for memory-safe, high-performance operation, backed by code review and cryptographic audits.

❖ Compliant & Audit-Friendly

Zakapi helps you align with GDPR, KVKK, HIPAA, eIDAS, and emerging regulations. Data minimisation and purpose limitation are built in. Each verification or database-backed policy check can produce an evidence package (proof + metadata) that regulators can independently verify from archives, without replaying queries on production data or seeing raw records.

❖ Open & Interoperable

We embrace open standards – W3C Verifiable Credentials, Decentralized Identifiers (DIDs), OIDC4VC/OIDC4VP, and the Hyperledger Aries framework for wallets. Our mobile wallet is based on the open-source Aries Bifold project. You’re never locked in: Zakapi works with national ID systems, third-party wallets, data warehouses, and existing IAM solutions.

❖ Built for Scale with Verifiable SQL

From national e-ID rollouts to enterprises with millions of customers, Zakapi scales. Our proof engine uses PLONKish circuits with custom gates for range checks, sorting, joins, group-by, and aggregation, and IPA-style polynomial commitments—aligned with the design ideas of PoneglyphDB—to support realistic, SQL-style workloads with non-interactive proofs. Circuit size grows roughly linearly with data size, so policies can be evaluated over large tables while remaining practical.

❖ Future-Ready (AI Enhanced)

We use AI/ML to improve development and operations—from using LLMs to test and optimise ZK circuits and SQL-style proof templates, to anomaly detection in verification logs. AI never touches raw personal data; it acts as a security co-pilot, spotting suspicious patterns, misconfigurations, or performance bottlenecks.

Core Capabilities at a Glance

Digital Identity Wallet

A user-held wallet (mobile & web) storing verified ID and eligibility credentials. Provides “Login with ZAKAPI” for passwordless authentication and one-click attribute sharing. Users control what they share and can see a full activity log of every request and proof.

Selective Disclosure Credentials

Issue credentials (ID cards, diplomas, KYC verifications, licenses, eligibility tokens, etc.) where the holder can prove specific facts—“over 21”, “has a valid passport”, “salary above threshold”, “resident in district X”—without revealing everything else. Built on the W3C VC 2.0 data model, with advanced selective disclosure techniques (e.g. BBS+ signatures, SD-JWT).

Zero-Knowledge Proof Services (Identity + SQL)

Out-of-the-box proof modules for:

• Age verification
• KYC/AML screening status
• Credit score thresholds
• Benefit and program eligibility
• Passport or driver’s licence validity

…and more, plus SQL-style verification of policies directly over sensitive datasets you control. Our non-interactive ZK circuits—using PLONKish, PoneglyphDB-inspired arithmetization—return yes/no answers with reusable proofs instead of raw data or database exports.

Integration APIs & SDKs

Developer-friendly REST and OIDC-compatible APIs for integrating into websites, apps, data platforms, and IAM systems. SDKs in JavaScript/TypeScript, Python, Kotlin/Swift, and more help teams:

• Request and verify ZK proofs from wallets
• Submit SQL-style verification queries against committed datasets
• Retrieve and cache non-interactive proofs for later audit

—all with integration timelines measured in days, not quarters.

Orchestration & Workflow

Built-in workflow automation ties into your existing processes. For example, when a user signs up for a new bank account, Zakapi can orchestrate:

1. Trigger identity proofing (via an integrated KYC vendor or e-ID login)
2. Issue a verifiable credential on success
3. Run SQL-style compliance checks (e.g., risk flags, jurisdiction filters) on the bank’s own data warehouse,
4. Generate a non-interactive ZK proof back to the bank confirming that all required checks passed on the committed dataset—

all in seconds, without manual review and without exposing underlying records.

Analytics & Monitoring

Dashboards for issuers, verifiers, and data owners show:

• Real-time stats (e.g., age verification pass/fail rates, proof volume per policy)
• System health and performance
• Alerts for anomalies (unusual query patterns, failed proof verifications, suspicious policy combinations)

Only non-sensitive telemetry is collected; Prometheus/Grafana-style monitoring under the hood keeps ops teams informed without exposing private data or query contents.

Trust & Transparency Indicators

• Designed to integrate with national and sectoral e-ID systems that collectively serve hundreds of millions of users and process billions of authentications per month, providing strong identity anchors where available.
• Built to work with high-adoption schemes (such as BankID- or SingPass-style national IDs) so programmes can bootstrap trust quickly in markets with mature digital identity.
• No centralised honeypot of sensitive personal data: Zakapi keeps raw identity data at the edge (in wallets and source systems) and uses cryptographic commitments plus ZK proofs to minimise what flows through the platform.
• Core wallet components and representative circuits are open-source and publicly auditable, enabling independent security review by regulators, researchers, and national labs.