The code is public, and the public testnet is the only place a third party tests it

The code. MintID’s implementation is open source under the Apache License 2.0. The main project holds all of it: the chain, the proof core and the holder library, the verifier and issuer services, the self-revocation relay, the SDKs, the test harness, a local stack that runs on your machine, and the developer documentation.

The specifications whose requirement identifiers the code cites are not part of the repository.

Contributions are welcome as issues and merge requests on the main project, signed off under the Developer Certificate of Origin. They are answered on a best-effort basis; there is no service-level agreement.

Reporting a vulnerability. Write privately to security@mintid.net. Never open a public issue, merge request or discussion for a suspected vulnerability. There is no bug bounty programme today and no response-time commitment. No independent security audit of this implementation has been completed: audits are scheduled as milestones, and each audit’s findings will be published with their remediation when it closes.

The verifier is your own service. A relying party runs the verifier SDK inside its own backend, or as a service next to it, and decides on its own service. Every deployment runs the same single verifying core; the clients and the MCP server carry no cryptography and no policy, and pointing them at somebody else’s verifier would hand that party the decision.

The install lines are in the developer documentation, starting at Getting started.

Try the tools on the public testnet. Add the testnet’s MCP endpoint to an agent runtime, for example Claude Code:

claude mcp add --transport http mintid-testnet https://mcp.testnet.mintid.net/mcp

Its challenges are bound to the testnet’s sandbox verifier, so its decisions carry no weight. If a decision gates your business, run the server yourself, in front of your own verifier.

Status: live.

The public testnet. The public testnet is the only MintID deployment a third party may use to test. It runs the same software and the same chain parameters as the single-node production chain, with its own chain, keys and hostnames. The single-node production chain is not for third parties and is never a place to test.

A KYC sandbox. Its issuer verifies nobody: when you open a KYC session you choose its outcome — approved at a grade from A1 to A4, declined, expired, abandoned, held in manual review, a date of birth the issuer cannot read, a provider that is unavailable, a session past its reuse window, and more — so every path of issuance and every error an integrator can meet is reachable on purpose. Nothing issued on the testnet carries weight: a credential, a grade, an agent or a decision obtained there says nothing about any person and must never be accepted anywhere else.

Limits. The production parameters: a new status root every 30 seconds, roots accepted up to 180 seconds, presentations that live 10 seconds. Agent minting is limited as everywhere, to 5 agents per person per hour and 10 active.

Reset policy. The testnet follows the software through ordinary deploys while the software keeps its shape. When it changes shape, the testnet is reset: a new chain identifier, new keys, an empty registry. Everything issued before is gone, with no migration and no notice period, because nothing on it carries weight.

Test tokens and the faucet. The public testnet runs on its own denomination, utestmint: every fee and bond on it is denominated in utestmint, on the same paths production charges, at the testnet’s fee parameters. What a third party pays from a grant are the fees the chain charges its own account: a verifier’s self-registration on the permissionless tier and its renewal, 1 000 000 utestmint each. Agent mint and lease fees are not paid by a third-party key: the issuer’s operator account settles them, so the sandbox journey (KYC, credential, agents) needs no tokens. Anyone can obtain utestmint, free, from the faucet: one grant per address per 24 hours and one grant per source per hour, 100 000 000 utestmint each. The faucet links no address to a person.

Hostnames

The chain identifier changes at every reset: read it, and the issuer and verifier ids, from the verifier’s status read rather than copying them from anywhere.

POST https://faucet.testnet.mintid.net/v1/faucet with the testnet address to fund answers with the transaction hash; GET https://faucet.testnet.mintid.net/v1/faucet/terms returns the testnet terms.

Testnet terms

These four statements are the public testnet’s terms.

1. Own denomination. The public testnet runs on its own denomination, utestmint. It is not the token of any other MintID chain, present or future.
2. Free from the faucet. Anyone can obtain test tokens free of charge from the public faucet, within its rate limits. Test tokens are not for sale and have no value.
3. No conversion. Test tokens cannot be transferred or converted to any other chain or asset. No snapshot, points programme or conversion promise attaches to them, and testing creates no claim.
4. Reset. The public testnet, every balance on it included, may be reset at any time without notice.

Reproduce the revocation trace. The revocation trace runs the revoked-agent sequence against a running deployment and times it, per revocation path: the issuer revokes an agent; the agent pulls its own kill switch through the privacy relay; a person’s identity credential is revoked and its agents follow; the issuer publishes an emergency root. During each one an adversarial agent keeps forcing proofs with the newest witness it can still obtain. The record shows, per path, the last accepted decision, the first refusal with the verifier’s reason code, the deny point the protocol guarantees, and the status root that carried the revocation, together with the verifier’s status before and after. A control agent that was never revoked shows whether a refusal is about the revocation or about the root a proof was made against.

The guarantee. An issuer revocation is refused by every verifier within the maximum root age plus a few seconds of clock tolerance — 185 seconds at the deployed values — and at once after an emergency root; an agent’s kill switch and a person-wide cascade within minutes, at bounds the record states for each path. The record also shows when this verifier actually refused in the run. That is an observation, faster than the bound and different from run to run; the bound is what you can rely on.

Run it from a clone of the main project, against the local stack:

uv run python test-harness/trace/revocation_trace.py --target local

Against the public testnet, with public access only (the emergency path and the verifier’s own log need the operator, and are marked as not read):

uv run python test-harness/trace/revocation_trace.py --target testnet