Dazr Identity developer docs

People can already use their Google or Microsoft account inside Dazr Identity, so your app does not need separate Google and Microsoft buttons next to it: one button instead of three.

Discovery and endpoints

Everything is described in the discovery document. Point your library at the issuer and it finds the rest.

WhatAddress
Issuerhttps://identity.dazr.eu
Discoveryhttps://identity.dazr.eu/.well-known/openid-configuration
Authorizationhttps://identity.dazr.eu/oauth/authorize
Tokenhttps://identity.dazr.eu/oauth/token
User infohttps://identity.dazr.eu/oauth/userinfo
Public keys (JWKS)https://identity.dazr.eu/oauth/jwks
Revocation (RFC 7009)https://identity.dazr.eu/oauth/revoke
Introspection (RFC 7662), web server apps onlyhttps://identity.dazr.eu/oauth/introspect
Sign-out (RP-initiated logout)https://identity.dazr.eu/oauth/logout
Verification reports, web server apps onlyhttps://identity.dazr.eu/oauth/verification-report

Register an app

An app in the Dazr Identity developer console: client ID, discovery URL, redirect URIs, scopes and the steps to connect it

Integration guides

Every stack below uses its own standard OpenID Connect support. You need three values from the console: the client ID, the client secret (web server apps only) and the redirect URI you registered. The rest comes from the discovery document.

Any OpenID Connect library

If your stack is not listed, any OpenID Connect client works. Check these settings:

The flow

  1. Create a random code_verifier (43 to 128 characters) and its code_challenge = base64url(SHA-256(verifier)). Create a random state and nonce. Keep all three in the user's session.
  2. Redirect to the authorization endpoint with response_type=code, client_id, redirect_uri, scope (always including openid), state, nonce, code_challenge and code_challenge_method=S256.
  3. The person signs in if needed and sees the consent screen with the actual data. When they allow it, they come back to your redirect URI with code, state and iss. Check that state matches and iss is https://identity.dazr.eu.
  4. On your server, POST to the token endpoint with grant_type=authorization_code, code, the same redirect_uri and the code_verifier.
  5. Verify the ID token: ES256 signature with a key from the JWKS (match the kid), iss, aud = your client ID, exp and your nonce. Use sub as the account key.
The Dazr Identity consent screen for an app called Ledgerline: it lists the name, email address and the verified organisation the user chose to share

The prompt parameter accepts none (answer at once with login_required or consent_required if the person would have to act), login (ask the person to sign in again) and consent (show the consent screen even when it was approved before). max_age is supported. Remembered consent: if the person approved the same scopes before, they go straight back to your app. If you ask for more later, the consent screen lists only what is new.

Scopes and claims

Ask only for what you need. Nothing outside this table exists: no contacts, no passwords. Files are read only through the Dazr Files API, with its own files.read scope.

ScopeClaims
openid (required)sub: a random ID for the person, the same for every app of your organisation and different for every other organisation
profilename (if set) and locale
emailemail and email_verified (always true)
addressaddress (formatted, street_address, locality, region, postal_code, country), only if the person saved one
organisationsorganisations: the organisations the person ticks on the consent screen, each with id, name, display_name, website, country, register_number, vat, vat_verified (true only when the EU VIES service confirmed the VAT number), verified, verification (see Verified organisations) and role (owner, admin or member)
offline_accessno claims; you also receive a refresh token

Claims appear in the ID token for the scopes the person approved. The user info endpoint returns the same set, with current values.

Verified organisations

Dazr verifies an organisation only when official sources prove two things: who the person is, and that they represent this organisation, with its name, register number and VAT number. Typically its director signs a short declaration with a qualified electronic signature (QES) and adds the company register extract that lists them; with an extract sealed by the register, such as an Italian visura camerale or a Dutch KVK extract, it is instant, otherwise Dazr reviews it. A qualified signature alone never makes an organisation verified. Every organisation in the organisations claim carries its current verification:

Verifying an organisation in Dazr Identity: the director signs the declaration with a qualified signature now or later by email, or uploads the company extract and an ID
verification.statusMeaning
unverifiedNot verified, or a verification failed, expired or was revoked (for example after the legal name or company number changed).
pendingVerification is in progress: the representative has been asked to sign, the company register extract is still missing, or Dazr is reviewing documents. method says which way was started, for example qes (the representative signs the declaration), qseal, pec, letter, video or documents.
verifiedVerified. method is qes_org (qualified signature, the certificate names the organisation), extract_sealed (qualified signature or reviewed ID, plus an extract sealed by the business register), qes_reviewed (qualified signature, extract checked by Dazr), qseal (the organisation’s qualified electronic seal), documents, pec (a code sent to the organisation’s certified email address, PEC, Italy), letter (a code posted to the registered office), video (a video call with Dazr) or extract. authority says what proved that the person represents the organisation (see below), and verified_at is a Unix time.

Only when the status is verified, verification.authority (and authority in webhooks) says how the link between the person and the organisation was proven. Every verification is documented evidence, checked once at the date shown. It is not a guarantee of the organisation’s solvency or conduct, and it does not show who owns the organisation.

verification.authorityWhat it proves
certificateDocumented evidence that the request was signed with a qualified electronic signature, or sealed with a qualified electronic seal, whose certificate names the organisation and its register number. Dazr checked the certificate against the EU trusted lists and for revocation.
register_extractDocumented evidence that a director or legal representative confirmed the request, with a qualified electronic signature or an identity document checked by Dazr, and that an extract sealed by the business register, at most 3 months old, lists them.
reviewedDocumented evidence that a director or legal representative confirmed the request, with a qualified electronic signature or an identity document, and that a person at Dazr checked a register extract, at most 3 months old, that lists them.
pecDocumented evidence that someone with access to the organisation’s certified email address (PEC, Italy), as listed in the business register, confirmed the request with a one-time code.
letterDocumented evidence that someone with access to the post at the registered office confirmed the request with a one-time code that Dazr sent there by letter.
videoDocumented evidence that a person at Dazr saw, in a video call, the identity document of the person who confirmed the request and an official extract that lists them as director or legal representative.

The same definitions are in the terms of use, section 7 of the Developer Terms and every verification report.

The boolean verified stays for compatibility and equals verification.status === 'verified'. Each organisation also has an id, the same one webhooks use.

When the status is pending or verified, verification.report_url is the address of its verification report.

"organisations": [{
  "id": "org_3k9x2m0q8w1v5t7a", "name": "Conti Logistica S.r.l.", "country": "IT",
  "register_number": "REA MI1234567", "vat": "IT12345678903", "vat_verified": true,
  "display_name": "Conti", "website": "https://conti.example",
  "verified": false, "verification": { "status": "pending", "method": "qes" }, "role": "owner"
}]

role and membership are read again at every token refresh and user info request: after a role change the next response carries the new role, and an organisation the person left or was removed from is no longer included. When an admin of the organisation disconnects your app, the organisation is left out of tokens issued before, until a member shares it with your app again in a new sign-in. display_name and website are null when the organisation has not set them; name is always the legal name.

Countries and times

Organisations in the 27 EU countries, Norway, Iceland, Liechtenstein, Switzerland and the United Kingdom can verify. The fastest route depends on the country:

CountryOrganisation verificationBusiness verification
ItalyInstant with a qualified signature and a visura sealed by the business register, or a few minutes with a code to the company’s certified email address (PEC)A visura no older than 3 months, checked by a person at Dazr, usually within one working day
NetherlandsInstant with a qualified signature and a digitally certified KVK extractFrom the KVK register, checked by a person at Dazr, usually within one working day
Austria, BelgiumInstant with a qualified signature and an extract sealed by the business registerAn official extract no older than 3 months, checked by a person at Dazr, usually within one working day
Norway, Denmark, Finland, France, Poland, CzechiaInstant with a qualified signature whose certificate names the organisation; otherwise an extract and an ID, checked by a person at Dazr, usually within one working dayFrom the online business register, checked by a person at Dazr, usually within one working day
United KingdomAn extract and an ID, checked by a person at Dazr, usually within one working dayFrom Companies House, checked by a person at Dazr, usually within one working day
Every other supported countryInstant with a qualified signature whose certificate names the organisation; otherwise an extract and an ID, checked by a person at Dazr, usually within one working dayAn official extract no older than 3 months, checked by a person at Dazr, usually within one working day
EverywhereA code by post (€100 excl. VAT, 3 to 10 working days) or a video call (€200 excl. VAT)A video call (€200 excl. VAT) when the representative has no phone camera

Times are typical, not guaranteed. Automatic means that documented rules decide when every check is clear; when one is not, a person at Dazr looks, usually within one working day. The help page for people asked to verify lists which register extract to get in each country.

Require a verified organisation

In the console, set Require a verified organisation to Verification started or Verified, or ask per request with acr_values=urn:dazr:org:verification-started or acr_values=urn:dazr:org:verified (the stricter of the two wins). Your app must also request the organisations scope.

The Require a verified organisation setting in the developer console: not required, verification started or verified

Someone without a qualifying organisation is taken through it in the same sign-in: their name, the organisation (with the VAT number checked in VIES), then the verification. They can sign right away, have the declaration emailed to themselves, or name someone else who signs. They then tick the organisation on the consent screen (only qualifying organisations can be ticked) and return to your redirect URI.

If someone else still has to sign, the person comes back with status pending, also when you asked for Verified: you receive a code, the claim says pending, and the ID token's acr is urn:dazr:org:verification-started instead of urn:dazr:org:verified. Always gate on verification.status, never on the fact that sign-in succeeded. With prompt=none you get interaction_required when the requirement isn't met.

Changes to the setting apply from the next sign-in. People already signed in are not signed out: refresh responses, the user info endpoint and webhooks always carry the current status, so use those to react for existing sessions.

Webhooks

Add a webhook URL (https) in the console. You see the signing secret once; you can rotate it. Dazr sends organisation.verification.updated when an organisation that one of your users shared with your app becomes pending, verified, failed or unverified. Apps that never received an organisation through consent never hear about it.

POST /your/webhook
Content-Type: application/json
Dazr-Event: organisation.verification.updated
Dazr-Delivery: dlv_8Fq2…
Dazr-Signature: t=1791021600,v1=5e0c…

{ "id": "evt_…", "type": "organisation.verification.updated", "created": 1791021600,
  "data": { "organisation": { "id": "org_3k9x2m0q8w1v5t7a", "name": "Conti Logistica S.r.l.", "country": "IT" },
            "status": "verified", "method": "qes_org", "authority": "certificate", "verified_at": 1791021598,
            "report_url": "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a",
            "subjects": ["Xo1c…"] } }

status is pending, verified, failed or unverified. subjects are the sub values, at your app, of the people who shared this organisation with it. Check the signature before you trust the body:

import crypto from 'node:crypto';
// raw = the request body exactly as received (a string), header = the Dazr-Signature header
function verifyDazrSignature(raw, header, secret) {
  const m = /^t=(\d+),v1=([a-f0-9]{64})$/.exec(header || '');
  if (!m || Math.abs(Date.now() / 1000 - Number(m[1])) > 300) return false; // reject old deliveries
  const want = crypto.createHmac('sha256', secret).update(m[1] + '.' + raw).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(want), Buffer.from(m[2]));
}

Answer with any 2xx within 8 seconds. Otherwise Dazr retries after about 5 minutes, 30 minutes, 2, 6, 12 and 24 hours, then marks the delivery failed. Every attempt has the same Dazr-Delivery ID, so ignore duplicates. The console lists recent deliveries, can resend one and can send a test event (webhook.test). Polling the user info endpoint works too.

Organisations and roles in your app

In a portal for business customers, map each Dazr organisation to a customer account (a tenant) in your app, and the person’s role in that organisation to a role in your app.

  1. Request the organisations scope. Each organisation the person ticks arrives with its id, role (owner, admin or member) and verification.
  2. Key the tenant on organisations[].id, never on the name or the VAT number: those can change.
  3. Map the role, for example owner and admin to your administrator role and member to your user role. Read it again at every sign-in and token refresh: roles change and people leave.
  4. Unlock business features only when verification.status is verified, or kyb.status is approved where you need business verification.
// claims: the ID token claims or the user info response
const ROLE = { owner: 'tenant_admin', admin: 'tenant_admin', member: 'tenant_user' };

const memberships = (claims.organisations || []).map((o) => ({
  tenantId: o.id,                              // e.g. org_3k9x2m0q8w1v5t7a
  role: ROLE[o.role] || 'tenant_user',
  verified: o.verification?.status === 'verified',
  businessVerified: o.kyb?.status === 'approved',
}));

With Keycloak

When Keycloak brokers Dazr Identity (see the Keycloak guide), add mappers under the identity provider’s Mappers tab, with sync mode Force. Keycloak reads these paths from the user info response, and a path can name one position in a list: organisations[0] is the first organisation the person ticked. For a portal with one customer account per person that is enough; if people work for several organisations, let them tick one, or read the full list in your app.

Mapper typeClaimResult
Attribute Importerorganisations[0].idUser attribute dazr_org_id: the tenant key
Attribute Importerorganisations[0].nameUser attribute dazr_org_name
Claim to Roleorganisations[0].role, claim value ownerRealm or client role tenant_admin
Claim to Roleorganisations[0].role, claim value adminRealm or client role tenant_admin
Claim to Roleorganisations[0].role, claim value memberRealm or client role tenant_user
Claim to Roleorganisations[0].verification.status, claim value verifiedRole verified_business

Then add a User Attribute mapper for dazr_org_id to your app’s client scope in Keycloak, so your app receives the tenant key in Keycloak’s own tokens, next to the roles.

Business verification (KYB)

Business verification, often called KYB (know your business), is the higher assurance level on top of organisation verification. It adds the business register, an ID check with a live selfie for the person acting for the company (the representative), and screening of the company and the representative against sanctions lists and lists of politically exposed persons (PEP). Beneficial owners are not part of it.

It costs €25 excl. VAT per organisation, once. The organisation pays, or your app pays for its customers from prepaid credit. If it stops before any ID has been checked, the payment is refunded in full.

Business verification in Dazr Identity on a computer: step 3 of 5, a large QR code to take the photos on the phone, the two photos that follow, and the live status of the phone
  1. Company information. The legal form, and the register number and registered office from the organisation’s legal details, confirmed by the person who starts it.
  2. Payment. €25 excl. VAT through Mollie, with an invoice on the organisation page. When your app pays from its prepaid credit, the organisation skips this step.
  3. ID and selfie. The person who starts it is a director or legal representative, or names one, who gets an email link with a one-time code (valid 14 days, reminders after 2 and 7 days), confirms their role and may add a power of attorney. The representative takes one photo of a passport (the photo page), ID card or residence permit (the front) and one front-facing selfie, live with the camera on the page; nothing can be uploaded. An AI model reads the document; Dazr checks the dates and the name, and for a passport the machine-readable zone (ICAO 9303 check digits). A Dazr reviewer compares the selfie with the document photo. On a computer the step shows a QR code that moves the capture to a phone, and the computer continues on its own. Without a phone camera, the representative can book a video call with Dazr instead (€200 excl. VAT, refunded in full if Dazr cancels or offers no time).
  4. Company register check. Name, status and directors from the official register where one is online (Norway, Denmark, Finland, France, the Netherlands, Poland, Czechia and the United Kingdom), otherwise from an official extract no older than 3 months, which Dazr reads automatically.
  5. Sanctions and PEP checks. The company and the representative against the EU, UN and OFAC sanctions lists and for politically exposed persons. Where the PEP database is not available, a name-only lookup in Wikidata gives an indication. The PEP result is recorded in the claim and the report and never stops the approval.
  6. Decision. A Dazr reviewer compares the selfie with the document photo and decides, with the results of the documented risk rules: they show when the ID check fails, a name matches a sanctions list, the register does not list the representative, or the company is not confirmed. The reviewer can approve, reject with a reason, ask the organisation for more information or run a check again, usually within one working day. High-risk cases need two reviewers. No case is rejected automatically.

Approved organisations are screened against the sanctions lists again every day and for PEP status every 30 days. A new sanctions hit moves the verification back to review; a new PEP hit is flagged and the verification stays approved. Either way your app hears about it.

An approved business verification is documented evidence that a director or legal representative, whose identity document and live selfie were checked, confirmed the request, that the business register or an official extract at most 3 months old shows the company, and that the company and that person were screened against sanctions lists and lists of politically exposed persons. Beneficial owners are not checked.

The kyb claim

Every organisation in the organisations claim carries kyb, and verification.assurance_level sums up both levels: none, basic (organisation verified) or kyb (business verification approved).

kyb.statusMeaning
noneNo business verification, or the last one was cancelled or expired.
in_progressStarted: the organisation is completing the steps.
in_reviewSubmitted and being reviewed by Dazr, or back in review after a new screening hit.
approvedApproved. Only then does the claim include verified_claims.
rejectedNot approved. The organisation can start a new one.

When approved, verified_claims follows the OpenID Connect for Identity Assurance format:

"kyb": {
  "status": "approved",
  "report_url": "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a",
  "verified_claims": {
    "verification": {
      "trust_framework": "dazr_kyb", "assurance_level": "kyb", "time": "2026-10-06T09:14:03.000Z",
      "verification_process": "kyb_7Tq2…",
      "evidence": [
        { "type": "electronic_record", "check_details": [{ "check_method": "data", "organization": "no-brreg" }] },
        { "type": "document", "check_details": [{ "check_method": "vpip" }, { "check_method": "pvr" }],
          "note": "ID document and a live, front-facing selfie of the representative; beneficial owners are not part of this verification" }
      ]
    },
    "claims": {
      "legal_name": "Fjordline Logistikk AS", "country": "NO", "registration_number": "912345678",
      "beneficial_owners": "not_verified",
      "started_by_representative": false,
      "screening": { "result": "no_match_found", "pep_checked": true, "last_screened_at": "2026-10-06T03:23:00.000Z" },
      "risk_level": "low"
    }
  }
}

beneficial_owners is always not_verified: business verification covers the company and the person acting for it, not who owns it. started_by_representative says whether the person who started it is also the representative whose ID was checked, or invited them by email. The claim never contains names, dates of birth or document details. Those stay in the audit report, which your app can fetch for organisations shared with it.

Require business verification

In the console, set Require a verified organisation to Business verification (KYB), or ask per request with acr_values=urn:dazr:org:kyb. Someone without it goes through every step in the same sign-in, one screen at a time, and continues to your app once Dazr has approved it; until then they get an email when it is approved and sign in again. The ID token’s acr is urn:dazr:org:kyb only once an organisation is approved, so always gate on kyb.status === 'approved' before you unlock anything that needs it.

Webhooks for business verification

The same organisation.verification.updated event is sent when the business verification status changes, including after re-screening. Its data adds:

"kyb": { "status": "approved", "approved_at": 1791021598, "risk_level": "low" },
"assurance_level": "kyb"

Business verification on its own

An organisation can also start business verification on its own, at https://identity.dazr.eu/verify/business?org=…, linked from its page in Dazr Identity, without any app asking for it. The result is the same: one verification per organisation, which every app it shares the organisation with can rely on. Images of ID documents and selfies are deleted 30 days after the decision; the results and the report are kept for 5 years after the verification ends, as anti-money laundering rules require.

How the decision is made

A Dazr reviewer decides every business verification, usually within one working day, and compares the selfie with the document photo. The reviewer takes a closer look when one of these applies:

Everything else is recorded and never blocks the approval. A possible politically exposed person (PEP) is flagged as screening.pep possible_match in the claim and the report; if the PEP database is not available, the claim says indication_only or not_screened. When the register lists no directors, authority is declared_by_representative. Decide yourself whether you need enhanced due diligence.

Countries without an online register

In countries without a live register, such as Italy, Germany, Spain or Belgium, the organisation uploads an official extract (a visura camerale, a Handelsregisterauszug, a nota simple). Dazr reads it automatically and checks the company name, the register number, the date (at most 3 months old) and the directors listed. A match is approved like a live register; a mismatch or an extract that cannot be read goes to a reviewer. A sealed extract is also checked for its register seal.

PEP, authority and flags in the claim

Field in verified_claims.claimsMeaning
screening.pepno_match_found, possible_match (flagged, not blocking), indication_only (only a name lookup in Wikidata ran) or not_screened.
authorityWhat showed that the representative may act: register, extract, dazr_verification or declared_by_representative.
flagsPresent when there is something to look at: pep_possible_match, high_risk_country.

Verification reports for audits

For every organisation shared with your app you can fetch a report of how and when Dazr verified it, for your audit file. It exists while the organisation is verified, and while its verification is in progress, showing what is done so far.

A report never contains ID document images or numbers, one-time codes, the PEC address, email addresses, or any address other than the registered office.

Sample reports

Two sample reports with a made-up organisation and made-up people, so your compliance team can see what you receive. They are signed with a sample key, not with Dazr’s keys: verify them with the sample public key below, never against the production JWKS.

Fetch a report

Authenticate with your client ID and client secret, as at the token endpoint: HTTP Basic (client_secret_basic), or the form body of a POST (client_secret_post). Never put the secret in the URL. Use the organisation id from the claims or webhooks, or simply the verification.report_url they carry.

curl -u "$DAZR_CLIENT_ID:$DAZR_CLIENT_SECRET" -o report.pdf \
  "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a&format=pdf&lang=en"
ParameterMeaning
orgThe organisation id.
formatpdf (default) or jws, the same facts as signed JSON.
langLanguage of the PDF: en (default), nl, it, de, fr, es or pl.
docInstead of the report: declaration, the director's signed declaration (qualified signature or seal only), or extract, the company register extract.

Only organisations that at least one of your users shared with your app through consent can be fetched. Any other organisation answers 404, the same as one that doesn't exist or has no verification; a wrong client secret answers 401. Apps without a client secret cannot fetch reports. Downloads are rate limited, and each one shows in the organisation's activity for its admins, with your app's name. In the console, your app's page lists the connected organisations with the same downloads.

Verify the signed JSON

With format=jws you receive a compact JWS (ES256, header typ dazr-verification-report+jwt), signed with the same keys as ID tokens. Its claims are iss, iat, jti (the document ID), sub (the organisation id), aud (your client ID) and report, the facts. The PDF carries the same JWS on its last page and in its metadata (DazrVerificationReport), so a PDF can be checked offline too.

import { createRemoteJWKSet, jwtVerify } from 'jose';

const jwks = createRemoteJWKSet(new URL('https://identity.dazr.eu/oauth/jwks'));
// jws = the response body of format=jws, or the text from the PDF metadata
const { payload } = await jwtVerify(jws, jwks, {
  issuer: 'https://identity.dazr.eu',
  audience: process.env.DAZR_CLIENT_ID,
  typ: 'dazr-verification-report+jwt',
});
console.log(payload.report.verification.status, payload.report.verification.authority);

Let an auditor check the signature

For a qualified signature or seal, doc=declaration returns the signed declaration exactly as it was uploaded: a signed PDF (PAdES) or a .p7m file (CAdES). An auditor can validate it independently with the European Commission's DSS demo validator: upload the file, keep the default validation policy and run it. The result shows whether the signature is qualified (QESig, or QESeal for a seal), who signed, and the trust service provider from the EU trusted list. doc=extract returns the company register extract; a register-sealed extract can be validated the same way.

The report is evidence for your audit file. Regulated firms remain responsible for their own customer due diligence.

Dazr keeps the signed declaration, the extract and the report data while the organisation is verified and for 5 years after its verification ends or the organisation is deleted. Keep your own copies for as long as your rules require.

Keys for old reports

Reports are signed with the same keys as ID tokens, and those keys rotate. Every key that ever signed a report stays published at https://identity.dazr.eu/oauth/jwks/archive, with dazr_status current, previous or retired, for at least 5 years after its last use. Verify an old report against the archive when its kid is no longer in the JWKS.

Identity verification (KYC)

Switch on Allow identity verification when a sign-in asks for it in the console, then ask for a verified person with acr_values=urn:dazr:person:kyc. Or tick Require identity verification on every sign-in. Without either setting, the acr value is ignored and nothing is charged. No extra scope is needed. During the sign-in, the person takes a live photo of their ID and one selfie on their phone; a computer shows a QR code. Dazr reads the document, compares the faces and screens the name against the EU, UN and OFAC sanctions lists. A person at Dazr reviews every check, usually within one working day.

Each verification costs €1.50 excl. VAT, from your organisation’s balance. The person never pays. A verification stays valid for 12 months. When another app asks for it, the person agrees on a consent screen instead of taking new photos, and that app pays €1.50, once per verification. Your app asking again with prompt=consent, or a sign-in with a verification your app already received, is free.

The ID token and user info carry the kyc claim, and acr is urn:dazr:person:kyc:

"kyc": {
  "verified": true, "verified_at": 1791356184, "valid_until": 1822892184,
  "given_name": "ANNA", "family_name": "LINDQVIST", "birthdate": "1985-03-15",
  "nationality": "NO", "document_country": "NO",
  "sanctions": { "status": "no_match", "screened_at": 1791356184, "lists": ["eu", "un", "ofac"] }
}

sanctions.status is no_match, or cleared_by_review when a listed name was similar and a reviewer found it is not this person. Document images and numbers are never shared. After 12 months the claim says "verified": false: ask again.

Verifications are real and charged while your app is in testing too.

Balance

Your organisation can pay for your customers’ business verification. In the console, open your app and tick We pay for our customers’ business verification. The price is taken from your organisation’s balance, one balance for every app of the organisation and for paid Dazr APIs. A verification costs €25 excl. VAT. When the balance is too low, your customer pays as usual, and your admins get an email.

Your app pays only for a sign-in that asks for business verification, and once per customer organisation. What an app pays per day for identity and business verification has a limit: €250 excl. VAT, unless you change it under Daily limit for verifications in the console. When it is reached, until the next day new identity verifications are refused, your customers pay for their own business verification, and your admins get an email.

Test mode

While your app is not live, a business verification started from a sign-in to it gives a test outcome. There is no payment, no ID photo and no reviewer, and the organisation’s real verification does not change. The last four digits of the organisation’s register number or VAT number choose the outcome:

Last four digitsOutcomekyb.status
0001 or any other numberApprovedapproved
0002Not approvedrejected
0003Sent to a reviewerin_review
0004Sanctions matchin_review
0005Expirednone

Test outcomes carry test: true in the claim, the webhook and the report, and only your app sees them while it is not live. Register numbers are unique on Dazr, so use your own, for example a Dutch KVK number like 1234 0002. In the console you can also send a test webhook for each outcome.

Tokens and lifetimes

TokenLifetime and rules
Authorization code60 seconds, single use, bound to your client, redirect URI and PKCE challenge. Using a code twice revokes the tokens it issued.
Access token10 minutes. A signed JWT (ES256, typ at+jwt) with aud = your client ID. Send it as Authorization: Bearer.
ID token10 minutes. ES256, with iss, sub, aud, exp, iat, auth_time, nonce and amr where known.
Refresh tokenOnly with offline_access. Rotates on every use: always store the new one. Sending an old refresh token again revokes the whole sign-in. Expires after 30 days without use and 180 days at most.

Signing keys rotate. Always pick the key by kid from the JWKS and refresh the JWKS when you see an unknown kid.

How the person signed in

The ID token’s amr (RFC 8176) says how the person signed in: ["otp"] for a one-time code by email, ["hwk", "user"] for a passkey with user verification, and ["fed"] for Google or Microsoft.

Language

Send ui_locales with the authorization request, for example ui_locales=de-AT de en. The first language Dazr supports is used for the sign-in and consent screens. The supported languages are in ui_locales_supported in the discovery document.

The sign scope

The sign scope in the discovery document is for the Dazr Sign API only. It lets an app send documents for signature on behalf of the person, and you enable it in the Dazr Sign portal. Sign in with Dazr Identity does not need it.

Dazr Files API and WebDAV (read only)

The Dazr Files API lets your app list and download files from Dazr Files, for example to back them up. It is read only: no request can upload, change, move, share or delete anything. Turn it on for your app in the console, on your app’s page under Dazr Files API. It uses the same app, client ID and secret as Sign in with Dazr Identity, and the same access tokens.

There are two ways in. An organisation’s owner or admin approves your app for the organisation’s shared files, and your server then gets tokens without a person (best for unattended backups). Or a person allows your app with the files.read scope, and your app reads that person’s own files.

The full reference, with every endpoint, examples, errors, limits, the changes feed and WebDAV setup for rclone and Synology, is in the Dazr Files API docs.

Organisation settings that affect sign-in

Errors

As long as your client ID and redirect URI are valid, errors come back to your redirect URI as error, error_description, state and iss: for example invalid_request (such as missing or plain PKCE), invalid_scope, unsupported_response_type, access_denied (the person cancelled, or the app is in testing and the person is not a member), login_required, consent_required and interaction_required (with prompt=none, when a required verified organisation is missing). With an unknown client or an unregistered redirect URI, Dazr shows an error page and never redirects. The token endpoint answers with JSON errors such as invalid_client, invalid_grant and unsupported_grant_type.

Sign-out

To sign someone out, send them to the sign-out endpoint with id_token_hint (or client_id), an optional post_logout_redirect_uri registered in your app settings, and state. Dazr asks whether they also want to sign out of Dazr Identity on that device, then sends them back. Revoke refresh tokens you no longer need at the revocation endpoint.

Testing and going live

A new app is in testing: only members of your organisation can sign in, and the consent screen says so. To go live, get your organisation verified in Dazr Identity, add an https:// redirect URI and request a live review in the console. Changing the name, purpose, privacy policy or data of a live app needs a new review.

Transfer an app to another organisation

An app can move to another organisation registered on Dazr, for example after a sale or a reorganisation. An owner or admin starts the transfer under Transfer app in the app’s settings, in Dazr Identity or in the Sign portal. An owner or admin of the other organisation accepts or declines it within 14 days. Until then, the sender can cancel and nothing changes.

The button

Use the wording "Sign in with Dazr Identity" and the Dazr logo as below. You may change the size, not the logo, colours or wording. Link it to your own route that starts the flow.

<a href="/auth/dazr" style="display:inline-flex;align-items:center;gap:10px;height:44px;padding:0 18px;border-radius:22px;background:#18203a;color:#fff;font: 600 15px/1 'Dazr', system-ui, sans-serif;text-decoration:none">
  <svg width="20" height="20" viewBox="0 0 100 100" aria-hidden="true"><path d="M64.133 21.813 A6.634 6.634 0 0 1 66.455 31.054 A2.552 2.552 0 0 0 67.912 34.849 A36.74 36.74 0 0 1 93.010 60.100 A2.654 2.654 0 0 1 88.914 62.984 A44.91 44.91 0 0 0 62.003 54.621 A3.062 3.062 0 0 0 59.161 56.689 A73.49 73.49 0 0 0 56.170 92.578 A2.654 2.654 0 0 1 51.111 94.052 A36.74 36.74 0 0 1 52.093 63.128 A1.225 1.225 0 0 0 52.182 62.260 L48.938 50.153 A1.429 1.429 0 0 0 47.187 49.142 L35.080 52.387 A1.225 1.225 0 0 0 34.373 52.898 A36.74 36.74 0 0 1 8.083 69.210 A2.654 2.654 0 0 1 6.830 64.091 A73.49 73.49 0 0 0 36.416 43.557 A3.062 3.062 0 0 0 36.785 40.062 A44.91 44.91 0 0 0 16.087 20.937 A2.654 2.654 0 0 1 16.536 15.948 A36.74 36.74 0 0 1 50.954 25.058 A2.552 2.552 0 0 0 54.969 24.423 A6.634 6.634 0 0 1 64.133 21.813 Z" fill="#ffffff"/></svg>
  Sign in with Dazr Identity
</a>

Dazr font. The button uses the Dazr font, which is free to use under the SIL Open Font License. Where Dazr is not loaded, the system font is used instead. Download the Dazr font (ZIP with TTF and WOFF2 files) to host it on your own site:

/* woff2 files from the ZIP, copied to /fonts/ on your site */
@font-face { font-family: 'Dazr'; font-weight: 400; font-display: swap;
  src: url('/fonts/dazr-regular-latin.woff2') format('woff2'); }
@font-face { font-family: 'Dazr'; font-weight: 700; font-display: swap;
  src: url('/fonts/dazr-bold-latin.woff2') format('woff2'); }
.dazr-signin { font: 600 15px/1 'Dazr', system-ui, sans-serif; }

A minimal Node.js example

Node 18 or later, no dependencies. A web server app with a client secret; for a public client, drop the Authorization header and send client_id in the body.

import crypto from 'node:crypto';
const issuer = 'https://identity.dazr.eu';
const clientId = process.env.DAZR_CLIENT_ID;
const clientSecret = process.env.DAZR_CLIENT_SECRET;
const redirectUri = 'https://app.example.eu/auth/dazr/callback';
const b64url = (buf) => Buffer.from(buf).toString('base64url');

// 1. Start: keep verifier, state and nonce in the user's session.
export function start(session) {
  session.verifier = b64url(crypto.randomBytes(32));
  session.state = b64url(crypto.randomBytes(16));
  session.nonce = b64url(crypto.randomBytes(16));
  const challenge = b64url(crypto.createHash('sha256').update(session.verifier).digest());
  return issuer + '/oauth/authorize?' + new URLSearchParams({
    response_type: 'code', client_id: clientId, redirect_uri: redirectUri,
    scope: 'openid profile email', state: session.state, nonce: session.nonce,
    code_challenge: challenge, code_challenge_method: 'S256',
  });
}

// 2. Callback: check state, exchange the code, verify the ID token.
export async function callback(session, query) {
  if (query.error) throw new Error('sign-in failed: ' + query.error);
  if (query.state !== session.state || query.iss !== issuer) throw new Error('state or issuer mismatch');
  const res = await fetch(issuer + '/oauth/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      Authorization: 'Basic ' + Buffer.from(clientId + ':' + clientSecret).toString('base64'),
    },
    body: new URLSearchParams({ grant_type: 'authorization_code', code: query.code, redirect_uri: redirectUri, code_verifier: session.verifier }),
  });
  const tokens = await res.json();
  if (!res.ok) throw new Error(tokens.error);
  const claims = await verifyIdToken(tokens.id_token, session.nonce);
  return { sub: claims.sub, email: claims.email, name: claims.name, tokens };
}

async function verifyIdToken(idToken, nonce) {
  const [h, p, s] = idToken.split('.');
  const header = JSON.parse(Buffer.from(h, 'base64url'));
  const { keys } = await (await fetch(issuer + '/oauth/jwks')).json();
  const jwk = keys.find((k) => k.kid === header.kid);
  if (!jwk || header.alg !== 'ES256') throw new Error('unknown signing key');
  const ok = crypto.verify('sha256', Buffer.from(h + '.' + p),
    { key: crypto.createPublicKey({ key: jwk, format: 'jwk' }), dsaEncoding: 'ieee-p1363' }, Buffer.from(s, 'base64url'));
  const c = JSON.parse(Buffer.from(p, 'base64url'));
  const now = Math.floor(Date.now() / 1000);
  if (!ok || c.iss !== issuer || c.aud !== clientId || c.exp < now - 30 || c.nonce !== nonce) throw new Error('invalid ID token');
  return c;
}

Limits

The authorization and token endpoints are rate limited. If you get HTTP 429, wait and try again; do not retry in a tight loop.

EndpointLimit
/oauth/authorize120 requests a minute per IP address
/oauth/token600 requests a minute per IP address, and 300 a minute per app
/oauth/userinfo1,200 requests a minute per IP address
/oauth/verification-report120 requests a minute per IP address, and 60 an hour per app
Business verification6 starts an hour per person, and 10 a day per organisation
Test webhooks30 every 10 minutes per person

Your obligations

Your organisation is an independent controller for the data it receives. The Dazr Identity Developer Terms set out what you may do with it, how to keep it secure and how to report breaches. Questions: hello@dazr.eu.

For your security and legal review: the security and procurement pack.