One identity layer, built on by anyone
Solidus is open infrastructure for verifiable credentials and decentralized identity — the building blocks applications across many domains compose into real products.
Issue once. Hold it. Present anywhere.
One verifiable credential, reused across every product — without a central vendor in the loop.
Issued once
A trusted issuer signs a W3C Verifiable Credential to your DID — a one-time check that becomes a reusable, cryptographically-verifiable claim.
Held by you
The credential lives in your wallet, not a vendor database. Selective disclosure (BBS+) lets you prove a claim without revealing the underlying data.
Presented anywhere
Any verifier checks the presentation cryptographically against the chain — no callbacks to the issuer, no shared vendor, no re-verification.
issue
issuer.did → your.did
type: VerifiableCredential
signed · on-chain anchor
Protocol capabilities
The network provides a small set of identity primitives. Applications across domains combine them — this is what each one does.
Credentials the holder owns and carries anywhere.
A credential issued on Solidus is a signed, standards-based object held by the user — not a record locked inside one provider’s database. The same credential can be presented to any application that trusts the issuer, with no re-onboarding.
Useful anywhere a credential is issued once and checked many times — finance, education, professional licensing, and more.
What it gives you
- User-held, not provider-locked
- Standards-based and interoperable
- Presented across unrelated apps
- No re-onboarding to reuse
Built on open standards
Solidus implements established, interoperable identity standards rather than a proprietary stack. That is what makes credentials portable and the protocol something anyone can build on.
| Standard | Layer | Status | What it enables |
|---|---|---|---|
| W3C Verifiable Credentials 2.0 | Credential format | Implemented | The data model for issuing, holding, and verifying tamper-evident credentials. |
| W3C DID (did:solidus) | Identifier | Implemented | Decentralized, owner-controlled identifiers anchored on the Solidus chain. |
| BBS+ selective disclosure | Privacy | Implemented | Reveal individual attributes — or prove statements — without exposing the whole credential. |
| SD-JWT VC | Credential format | Implemented | Compact, selectively disclosable credentials aligned with emerging wallet ecosystems. |
| OpenID4VCI | Issuance | Implemented | A standard flow for issuing credentials into holder wallets over familiar OpenID rails. |
| Status List | Revocation | Implemented | Privacy-preserving credential status so verifiers can check revocation without tracking holders. |
| EdDSA · BLS | Signatures | Implemented | The signature schemes behind credential proofs and validator consensus. |
“Implemented” means the standard is supported by the protocol and SDKs today. How any given application maps these capabilities to its own regulatory obligations is up to the application — Solidus provides the primitives, not legal advice.
Across every domain
The same identity primitives compose into products in any sector that issues, holds, or checks a credential.
Running on the protocol
Everything above, in one application
Portability, selective disclosure and delegation are easy to describe separately and hard to make work together. Tamga is a demo that runs all three at once, on testnet, that you can open right now.
One credential, six registries
A single credential issued in one member state and accepted in the others — each with its own issuer DID, resolved through a shared trust registry rather than a shared database.
Disclosure that stays minimal
A verifier asks for nationality and over-18. It receives nationality and over-18 — and cryptographically cannot learn the birthdate behind the claim, or the name beside it.
An agent that cannot overspend
The holder signs a scoped mandate; an autonomous agent transacts against it. The scope is enforced by the signature, not by the agent’s good behaviour — so exceeding it fails.
Built by the Solidus team for a hackathon, and running on testnet against mock trust registries with demo keys. It is a demonstration of the protocol, not a production deployment or a customer. The interface is in Turkish.