Developer
first identity APIs and SDKs.

Open APIs and SDKs for Seamless Integration

Zakapi isn’t a black box; it’s a developer toolkit for building PoneglyphDB-style, non-interactive verification into your apps. You focus on product logic; we handle the zero-knowledge proofs over committed datasets, SQL-like policy predicates, and PLONKish circuits under the hood.

Whether you’re:

• building a mobile app that needs to verify a user’s age or residency,
• adding “Login with Zakapi” to a web platform, or
• wiring an enterprise backend to request and validate proofs,

you integrate through clear REST APIs, SDKs, and widgets, not raw cryptography.

Our mantra for developers: simple integration, powerful math.

You call straightforward APIs; we turn your policies into circuits and non-interactive proofs.

Key Integration Flows

We support multiple integration patterns to match your architecture, all backed by the same PoneglyphDB-style pipeline:

policy → circuit → proof → verification.

Client-side (Browser) IntegrationUse our JavaScript SDK or UI widgets to embed “Verify with Zakapi” directly in your front end. For example:

<script src="https://cdn.zakapi.com/zakapi-widget.js"></script> <zakapi-proof-requestissuer="did:gov:countryX"claim="age>=18"onSuccess="handleProofSuccess"onError="handleProofError"> Verify Age </zakapi-proof-request>

This renders a “Verify Age” button. On click:

1. Zakapi opens a QR / deep link to the user’s wallet.
2. The wallet generates a non-interactive ZK proof that age >= 18 over a committed registry, using PLONKish circuits (inspired by PoneglyphDB’s SQL gates).
3. Your handleProofSuccess gets a token / result you can trust and verify without ever touching the underlying DOB.

The JS SDK handles wallet communication (OIDC/OAuth, QR, deep-link), similar to adding a payment or “Login with X” button—but here it’s “Verify with Zakapi” and proof-backed.

Server-side REST API

Prefer to orchestrate flows on your backend? Use our REST endpoints:

1. Your backend calls /request-proof with what you need (e.g., KYC status, age, sanctions check).
2. Zakapi returns a request_id and QR / deep link to present to the user.
3. The user responds from their wallet.
4. Zakapi notifies your callback or you poll /proof-status.
5. You fetch the proof (e.g., signed token + embedded ZK proof) and verify.

Everything is language-agnostic (REST/JSON + OpenAPI). We provide examples for common stacks—Node, Python, Java, Go, etc.—so you don’t need to think about circuits or commitments at all.

Mobile SDKs

For native apps, our Android/iOS SDKs give you a one-call experience:

ZakapiClient.requestProof( context = this, request = ProofRequest( issuer = "did:bank:KYCissuer", claim = "kycCheck=pass" ), onResult = { proofResult -> if (proofResult.verified) proceed() else showError() } )

Under the hood we:

• Deep-link or intent into the Zakapi Wallet,
• Pass the proof request,
• Receive and locally verify the non-interactive ZK proof,
• Return a simple verified flag + any disclosed fields.

On iOS, the flow uses universal links / secure webviews. The goal: one call → verifiable result.

Verification SDKs (Back-end)

Once your backend receives a proof (e.g., JWT / JSON with embedded ZK proof), you often want to verify independently.

We ship verifier SDKs (Java, Python, JS, C#, etc.) that handle:

• Parsing the proof format
• Resolving issuers’ public keys (via DIDs / trust registry)
• Checking signatures and the ZK proof
• Returning simple valid / invalid plus extracted claims

Example in Node.js:

const { ZakapiVerifier } = require('zakapi-sdk'); const verifier = new ZakapiVerifier(trustStore); const result = await verifier.verifyProof(proofToken); if (result.valid) { console.log("Proof ok, claims:", result.claims); } else { console.error("Proof invalid:", result.error); }

You get the PoneglyphDB-style guarantees (query correctness over committed data) through a single function call.

Documentation, Tooling, and Sandbox

• Developer Portal: Guides, API references, and tutorials (e.g., “Verify Age on Web”, “Backend KYC check”, “OIDC login with Zakapi”). A playground lets you create proof requests and inspect raw payloads.
• OpenAPI Spec & SDKs: We publish a full OpenAPI spec so you can auto-generate clients or use our maintained SDKs.
• Sample Apps & Repos: Example verifiers and wallet integrations (Node, iOS, Android, etc.) to copy, run, and extend.
• Community Support: Stack Overflow tag, Slack/Discord, and responsive engineers who know you need quick, concrete answers.
• Testing Environment: A dedicated sandbox with demo issuers (“Test Passport Authority”, “Test Bank KYC”) and a test wallet mode, so you can do full end-to-end integration with no real user data.

DevOps & CI/CD Friendly

If you self-host parts of Zakapi:

• Use our Docker images and Helm charts for repeatable deployments.
• Follow clear changelogs and semantic versioning.
• See public CI status and tests, including interop tests against open VC/DID specs, so you know what you ship.

Security for Developers

“Why should I trust Zakapi’s outputs?”

Because you don’t have to just trust them:

• Every proof includes metadata so you can fetch and check the correct public keys.
• Our verifier SDKs do the same math you’d do with lower-level libraries; you can bypass them and use your own crypto stack if you like.
• Circuits, verification code, and formats are based on open standards and open-source implementations—no proprietary magic.

As with PoneglyphDB, the core promise is: correctness and privacy are guaranteed by math + open code, not marketing.

Example: QuickLoan in a Few Steps

You’re a dev at a fintech “QuickLoan”:

• Business rule: applicants must be 21+ and hold a valid driver’s license.
• Integration:

1. Frontend calls zakapi.requestProof({ claims: ["age>=21", "hasValidLicense=true"] }).
2. Wallet shows the request; user approves.
3. Backend receives proof tokens.
4. Backend uses Zakapi verifier SDK to check them; gets valid=true plus minimal claims.
5. You mark user as verified and let them proceed—without ever storing birthdate or license number.

If you want to re-check in a year, you just request a fresh proof; the wallet and issuers handle expiry and revocation.

Developer Support and Roadmap

• Support: Email + community channels; enterprise plans include dedicated technical contacts and code-level help.
• Roadmap: Public roadmap and feedback loop for new standards, SDK improvements, and language support.
• Examples & Hackathons: Regular sample projects (e.g., Zakapi + smart contracts, Zakapi + IoT) to show what’s possible and give you starter kits.

In short: Zakapi is a developer-first identity and proof platform.

We hide the complexity of PoneglyphDB-style, non-interactive zero-knowledge verification over committed data, and expose clean, familiar APIs and SDKs.

If you can integrate OAuth or Stripe, you can integrate Zakapi—and ship world-class, privacy-preserving, mathematically provable identity in just a few lines of code.