Pay per verification, not again for the credential you already own
Every number below is a modeled figure, shown with its arithmetic, not a rate someone is currently paying.
That candor matters here specifically, because this page's whole argument is a cost model, and a cost model you can't audit isn't worth reading.
Two prices, not one
Reusable KYC means the first check and every check after it have structurally different prices:
- First verification: a full identity check: document capture, face match, and the checks a relying party actually needs to satisfy its own obligation. This is the expensive step, for Solidus and for every incumbent vendor. There is no way around paying it once.
- Every reuse (a relying party accepts the W3C Verifiable Credential the user already holds from that first check, cryptographically verifies the issuer's signature, and optionally requests NLnet NGI Zero grant). No new document upload, no new face match. That's a verification, not a re-verification, and it is modeled to cost a small fraction of the first check.
Both numbers are modeled against Solidus's own draft KYC L2 tier and a named competitor's own published range, not invented for this page. See the worked example below for exactly where those inputs come from.
The worked example: this is the artifact, not a rate card
Take Solidus's modeled KYC L2 rack rate: $5.00 for the first check, $0.05 for each reuse. Take Sumsub's own sourced range, $1.50–$2.50 per verification, and use $1.50 as the representative first-check price, the low end, the case most favorable to the incumbent, not a number picked to flatter Solidus.
Model the two cumulative-cost curves over n verifications of the same person:
| Formula | Meaning | |
|---|---|---|
| Solidus | 5.00 + 0.05n |
one first-check cost, plus a flat $0.05 per reuse |
| Sumsub-style (re-verifying at full price each time) | 1.50(n + 1) |
no reuse discount modeled, every check is a first check |
Solve for the crossover, where the two lines meet:
5.00 + 0.05n = 1.50(n + 1)
5.00 + 0.05n = 1.50n + 1.50
3.50 = 1.45n
n ≈ 2.4
Solidus starts more expensive. The first check costs more than Sumsub's representative price, say that plainly, don't bury it. But by the third time the same person needs to be verified anywhere in the network, the reuse model has already paid for the gap, and every verification after that is $0.05 against $1.50. At n = 10, Solidus totals $5.50; the re-verify-every-time model totals $16.50.
This is a modeled comparison of published/modeled rate inputs, not a claim about what any actual customer pays today, no one does yet. It also assumes the relying party accepting the reused credential is verifying a signed credential the user already holds, not discharging its own regulatory KYC obligation by proxy; reuse is sold as convenience and cost, never as an obligation transfer to Solidus.
The same $5.00 / $0.05 / n ≈ 2.4 inputs are used on /reusable-credential, so the two pages never
disagree about the underlying math, check there for the architectural reason reuse can be priced
this low (a signed credential the holder re-presents, not a repeated document check).
Plan tiers and self-serve
Verify offers a self-serve tier with a free verification allowance for evaluation and low-volume integration: the exact quota is being finalized and isn't published here until it matches what the live signup flow actually grants. Above that, usage is metered per verification at the modeled rates above, with volume pricing for relying parties running sustained reuse traffic (software vendors embedding Verify into an existing PMS, POS, or dealer workflow), request current terms directly rather than reading them off a static table that can drift from what's actually configured.
Vendor channel
Software vendors who embed Verify into a product they already sell, a PMS, a POS system, a
telecom dealer console, can pass reuse savings through to their own customers rather than
absorbing them; the revenue-share mechanics for that channel are a /partners conversation, not a
line item here.
Why the second price can be this low
The short version: a W3C Verifiable Credential is signed once and re-presented, not re-issued. The
full architectural case, why that signature is what makes reuse cheap, and what selective
disclosure actually protects, is on
/reusable-credential, not repeated here.
For the underlying definitions this page extends rather than restates, cost-per-verification, re-verification cost, total cost of ownership, credential portability, see the Lexicon.