Blog · architecture

How MintID builds multi-language verifier clients around one core

MintID’s verifier SDKs share one verifying core embedded in Python, never rewritten per language. TypeScript and later languages are thin clients with no cryptography and no policy. They call a verification service you host yourself, so no binding can weaken a check. An implementation audit of the core is a scheduled milestone, and its findings will be published.

Updated 2026-10-26: the SDKs are now published on PyPI and npm, and the verifier SDKs run server-side. Updated 2026-10-04: delivery and wording.

We announced the MintID SDKs and delivered them to integrators from a tagged release. Every binding ships with the same acceptance checks, the same ten-second presentation lifetime, and zero policy knobs. This post explains how SDKs in several languages carry that single guarantee. The specification now locks in this design. Rewriting the verification in each language is a common way to build multi-language SDKs, and it is a security mistake.

One verification pipeline across all languages

A common approach to multi-language SDKs is to rewrite the verification pipeline in each language. Teams build a TypeScript implementation for Node, another for the commercial web, and a Python implementation for the data stacks. Every rewrite is a fresh chance to get a check subtly wrong. A different cryptographic library brings different edge cases. Clocks behave differently, or code disagrees on what “expired” means a millisecond either side of the boundary. Separate implementations create separate attack surfaces and separate audits that can disagree. Divergence compounds with every bugfix that lands in one language first.

To prevent divergence, the specification requires that the verification pipeline exist in exactly one implementation. That core is now in production, and the specification rejects rewriting it per language.

Embedding in Python and delegating from thin clients

The core is packaged directly for Python. The Python SDK embeds the pipeline in your backend, as the verifier pages describe.

Every other SDK is a thin client, starting with TypeScript and adding further languages as demand appears. A thin client issues challenges and delegates every verification decision to a service that the registered verifier runs itself alongside its own backend. That service runs the same verifying core inside the verifier’s own infrastructure. The thin clients contain no cryptography and no policy. Because of this, a client cannot skip an acceptance condition, stretch a presentation lifetime, or mis-verify a proof. All verification happens inside the self-hosted service.

MintID does not host verification for you. Verification runs inside your own infrastructure, with no central MintID endpoint or API in the path. In service mode, you deploy the verifying core on your own machines and hold your own keys. Keys and challenge issuance remain server-side in every configuration. The verifier SDKs run on your servers. They do not run in a browser.

Every SDK passes a shared conformance suite before release

Every SDK in every language must pass one shared conformance suite before release, so thin clients behave identically to the embedded Python library. The suite tests the same challenges, responses, expected decisions and reason codes across every binding. A registered verifier gets the same answer when its backend embeds the verifying core directly and when it calls the core through a thin client. The specification requires every SDK to pass the suite before it ships.

Build order and the frozen service contract

The build order is fixed. Python comes first, because it packages the core itself. Next is the service contract that the clients build against, which is frozen and versioned as a first-class artefact. Then comes the TypeScript client, followed by further languages as demand appears. We build the clients against this frozen contract so they stay thin over time.

We first delivered everything here from a tagged release. The SDKs are now published on PyPI and npm, and the current versions are on the developers page. The design is now fixed around one implementation. A backend embeds it in Python or reaches it through a thin client, and we do not rewrite it per language. The protocol specification fixes the acceptance rules, so an integrator cannot change them from any language.

Integrating the verifier SDKs

You can embed the core in Python or point a thin client at your own verification service. The SDKs are published on PyPI and npm. The public testnet is open for your tests.