Verifique um utilizador ou uma empresa uma única vez. Partilhe o resultado com um parceiro, este faz o onboarding da mesma pessoa instantaneamente. Sem um segundo fluxo, sem uma segunda selfie. Funciona para KYC e KYB. Criado para Banking-as-a-Service, grupos multimarca, finanças incorporadas e marketplaces com subplataformas.
Robinhood Ventures
Criado para ecossistemas de parceiros
O seu utilizador verifica-se uma vez na sua aplicação. O seu parceiro, o seu patrocinador BaaS, a sua marca irmã, o seu marketplace a jusante, precisa do mesmo registo. Envie-lhes um token de partilha único. Eles resgatam-no e obtêm a verificação completa. O utilizador nunca vê um segundo fluxo.
Escolha qualquer verificação concluída, aprovada, recusada ou em revisão, e peça à Didit um token de partilha. O token expira em uma hora por predefinição; pode estendê-lo de um minuto até um dia inteiro.
Entregue o token ao seu parceiro através do seu próprio backend, um webhook, uma fila, uma chamada REST. O token só funciona para o parceiro que nomeou quando o criou. Ninguém mais o pode resgatar.
O seu parceiro resgata o token e escolhe como fazer o onboarding do utilizador, confie na sua decisão e aprove instantaneamente, ou importe os dados em bruto e deixe a equipa de conformidade deles tomar a decisão.
A Didit clona todo o registo, documentos, selfie, correspondência facial, AML, dados de registo, UBOs, para o espaço de trabalho do seu parceiro. Com a mesma estrutura de uma nova verificação, com um rasto de auditoria claro até ao original.
POST /v3/session/[id]/share/
POST /v3/session/import-shared/
Onboarding instantâneo · ou a sua própria revisão
session_kind: utilizador | empresa
utilizador · KYC
empresa · KYB
Onde uma verificação serve muitos
Apenas concluído · idempotente · nível de auditoria
$ curl -X POST https://verification.didit.me/v3/session/$SID/share/ \
-H "x-api-key: $DIDIT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"for_application_id": "partner-app-uuid",
"ttl_in_seconds": 3600
}'{ "share_token": "eyJhbGciOi…" }$ curl -X POST https://verification.didit.me/v3/session/import-shared/ \
-H "x-api-key: $DIDIT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"share_token": "eyJhbGciOi…",
"workflow_id": "wf_partner_kyc",
"vendor_data": "partner-user-42",
"trust_review": true
}'{ "status": "Aprovado", "tipo_sessão": "utilizador" }# Didit B2B Reusable KYC — partner-to-partner KYC sharing
You are integrating Didit's B2B Reusable Know Your Customer (KYC) into <my_stack>. The recipe is server-to-server: one Didit application (Service X) mints a short-lived JSON Web Token (JWT) share token for a finished session; a partner Didit application (Service Y) imports the token and Didit clones the full verified session into Service Y. Works for both KYC and Know Your Business (KYB) sessions.
Built for Banking-as-a-Service (BaaS) sponsor banks, multi-brand financial groups, embedded finance through partner banks, marketplaces with regional or vertical sub-platforms, on-ramp + exchange ecosystems, white-label resellers, and B2B KYB consortia where the same legal entity onboards once and serves many. Every URL, header, and enum value below is canonical — do not paraphrase or "improve" them.
## 1. Provision both applications
- Sign up: https://business.didit.me (no credit card required).
- Or provision programmatically: POST https://apx.didit.me/auth/v2/programmatic/register/
- Create TWO applications in your Didit organisation. One acts as Service X (mints share tokens), the other as Service Y (imports them). In production these will usually live in different organisations — one per partner.
- Each application has its own `x-api-key`. Service X uses its own key to mint; Service Y uses its own key to import.
## 2. Service X — mint a share token
Service X picks a finished session it owns and posts to the share endpoint:
POST https://verification.didit.me/v3/session/{sessionId}/share/
Headers:
x-api-key: <Service X api key>
Content-Type: application/json
Body:
{
"for_application_id": "<partner-application-uuid>",
"ttl_in_seconds": 3600
}
Bounds on `ttl_in_seconds`: min 60, max 86400, default 3600.
Requirements:
- The session must be in a FINISHED status: "Approved", "Declined", or "In Review".
- The API key must hold the `write:sessions` privilege.
- `for_application_id` must be a real Didit application uuid — usually the partner's app.
Response: 201 Created with the JWT in the `share_token` field plus `for_application_id` and `session_kind` ("user" or "business" — Didit detects this from the source session and embeds it in the token):
{
"share_token": "eyJhbGciOiJIUzI1NiJ9...",
"for_application_id": "partner-app-uuid",
"session_kind": "user"
}
## 3. Transmit the token to Service Y
Service X transmits the `share_token` to Service Y over a pre-arranged backend channel — REST, message queue, signed webhook, anything you control. The token is scoped to Service Y's application and useless to any other application.
## 4. Service Y — import the shared session
Service Y posts the token to the import endpoint:
POST https://verification.didit.me/v3/session/import-shared/
Headers:
x-api-key: <Service Y api key>
Content-Type: application/json
Body:
{
"share_token": "<jwt from step 2>",
"workflow_id": "<Service Y's own workflow id>",
"vendor_data": "<Service Y's internal user id>",
"trust_review": true
}
`trust_review`:
- `true` → the imported session preserves the original status ("Approved" / "Declined" / "In Review"). Service Y onboards the user instantly. Use when Service Y fully trusts Service X's decision (sister brand, regulated partner with a signed data-sharing agreement).
- `false` → the imported session lands in "In Review" so Service Y's compliance team makes its own call. Safe default for new partner relationships.
Response: 201 Created with a brand-new session in Service Y's application:
{
"session_id": "<new uuid>",
"session_number": <int>,
"session_kind": "user" | "business",
"status": "Approved" | "In Review" | "Declined",
"shared_from_session": "<original session uuid in Service X>",
"vendor_data": "<Service Y's internal user id>",
"id_verifications": [...],
"liveness_checks": [...],
"face_matches": [...],
"aml_screenings": [...],
"database_validations": [...],
"proof_of_address": [...],
"phone_verifications": [...],
"email_verifications": [...]
}
For a `session_kind: "business"` token Didit clones the KYB shape instead. KYB session statuses are UPPER_SNAKE_CASE (not Title Case like KYC):
{
"session_id": "<new uuid>",
"session_kind": "business",
"status": "APPROVED",
"shared_from_session": "<original business session uuid>",
"vendor_data": "<Service Y's internal business id>",
"registry_checks": [...],
"key_people_checks": [...],
"document_verifications": [...],
"aml_screenings": [...],
"questionnaires": [...]
}
A new User or Business entity is auto-created in Service Y if one with the supplied `vendor_data` doesn't already exist.
## 5. Idempotency, expiration, errors
| Status | Reason |
|--------|--------|
| 401 | Share token invalid or past `exp` — request a new one. |
| 403 | Token not intended for your application, OR session already imported into your app. |
| 404 | Original session no longer exists. |
| 404 | `workflow_id` not found in your application. |
The duplicate-import check is enforced against the (share_token, partner application) pair.
## 6. Webhooks (optional, only when Service Y wants async updates)
Service Y can register a webhook destination once via:
POST https://verification.didit.me/v3/webhook/destinations/
Body: url, subscribed_events: ["status.updated"]
Every webhook delivery carries an `X-Signature-V2` header you MUST verify before trusting the payload. HMAC-SHA256 verification MUST run against the raw body bytes (the raw payload as Didit sent it) BEFORE any JSON parsing — re-serialising the parsed body changes whitespace and key order, which invalidates the signature.
Algorithm:
1. sortKeys(payload) recursively
2. shortenFloats (truncate trailing zeros after the decimal point)
3. JSON.stringify the result
4. HMAC-SHA256 with the secret_shared_key
5. Hex-encode, compare to the X-Signature-V2 header.
## 7. Hard rules — do not change
- Base URL for /v3/* endpoints is verification.didit.me (NOT apx.didit.me).
- Auth header is x-api-key (lowercase, hyphenated).
- Webhook signature header is X-Signature-V2 (NOT X-Signature).
- Status casing matches exactly: "Approved", "Declined", "In Review", "Not Finished" (Title Case With Spaces — KYC convention).
- session_kind is lowercase: "user" or "business".
- The share API is BUSINESS-to-BUSINESS sharing. Service X and Service Y are responsible for the data-sharing legal basis under General Data Protection Regulation (GDPR), UK GDPR, and any cross-border transfer rules. Didit ships the technical capability; you ship the data-sharing agreement.
## 8. Pricing reference (public)
- Service X already paid for the original verification (full KYC bundle is $0.30 or KYB session starts at $2.00; see didit.me/pricing).
- Service Y pays nothing on the import side — `POST /v3/session/import-shared/` is included with every plan.
- 500 free verifications every month on every account (applies to fresh captures, not imports).
## 9. Verify your integration
- Sandbox starts on signup at https://business.didit.me — no separate flag.
- Create two sandbox applications: one as Service X (issuer), the other as Service Y (importer). Use Service X's API key to mint a token for a finished sandbox session, hand the token off, use Service Y's API key to import.
- Switch to live: flip each application's environment toggle in console.
When in doubt:
- https://docs.didit.me/sessions-api/share-session/overview
- https://docs.didit.me/sessions-api/share-session/share
- https://docs.didit.me/sessions-api/share-session/import
- https://docs.didit.me/core-technology/reusable-kyc/share-kyc-via-api
$0 / mês. Não é necessário cartão de crédito.
Pague apenas pelo que usa. Mais de 25 módulos. Preços públicos por módulo, sem taxa mínima mensal.
MSA e SLA personalizados. Para grandes volumes e programas regulados.
Comece grátis → pague apenas quando uma verificação for executada → desbloqueie o Enterprise para um contrato personalizado, SLA ou residência de dados.
A Didit é uma infraestrutura para identidade e fraude, a plataforma que gostaríamos que existisse quando estávamos a construir os nossos próprios produtos: aberta, flexível e amigável para programadores, para que funcione como uma parte real da sua stack em vez de uma caixa preta que integra à volta.
Uma API cobre a verificação de pessoas (KYC, know your customer), a verificação de empresas (KYB, know your business), o rastreio de carteiras de cripto (KYT, know your transaction), e a monitorização de transações em tempo real, numa stack construída para ser:
A base subjacente: mais de 14.000 tipos de documentos em mais de 48 idiomas, mais de 1.000 fontes de dados e mais de 200 sinais de fraude em cada sessão. A infraestrutura Didit aprende dinamicamente com cada sessão e melhora a cada dia.
O KYC Reutilizável B2B permite que uma empresa entregue um utilizador ou empresa verificada a outra empresa, para que o parceiro integre a mesma pessoa sem ter de executar a verificação novamente.
Funciona em dois passos:
O seu parceiro escolhe a velocidade de integração. Confie na sua decisão e aprove o utilizador instantaneamente, ou puxe os dados brutos e deixe a sua equipa de conformidade tomar a decisão.
Funciona tanto para Know Your Customer (KYC) como para Know Your Business (KYB), a mesma chamada, ambos os formatos.
Referência completa: docs.didit.me/sessions-api/share-session.
Qualquer modelo de negócio onde uma plataforma integra um utilizador uma vez e várias plataformas parceiras precisam da mesma verificação:
Se conseguir escrever um acordo de partilha de dados com o seu parceiro, esta API fornece a parte técnica.
O fluxo completo normalmente leva menos de 30 segundos de ponta a ponta, pegar no documento de identificação, tirar foto ao documento, tirar selfie, feito. É o mais rápido do mercado. Os fornecedores de KYC legados geralmente levam mais de 90 segundos para o mesmo fluxo.
No back-end, a Didit devolve o resultado em menos de dois segundos no p99, medido desde o momento em que o utilizador termina a selfie até ao momento em que o seu webhook é acionado. A captura móvel é otimizada para telemóveis lentos e redes lentas: compressão progressiva de imagem, carregamento preguiçoso do kit de desenvolvimento de software e uma transferência com um toque do desktop para o telemóvel via código QR se o utilizador começar na web.
POST /v3/session/import-shared/ devolve 201 Created com uma nova sessão na sua aplicação, novo session_id e session_number, payload completo clonado da origem.
Campos chave:
status, Approved / Declined / In Review (preservado quando trust_review: true, forçado para In Review quando trust_review: false).session_kind, user (KYC) ou business (KYB).shared_from_session, aponta para a sessão original na aplicação de origem. Sinal canónico de que esta sessão foi importada, não capturada de novo.vendor_data, o ID interno de utilizador / empresa que VOCÊ passou na chamada de importação.id_verifications, liveness_checks, face_matches, aml_screenings, database_validations, proof_of_address, location_checks, phone_verifications, email_verifications.registry_checks, key_people_checks (com os seus KYCs aninhados), document_verifications, aml_screenings, questionnaires.Formato idêntico a uma sessão nova, o seu handler de webhook existente lê-o da mesma forma.
Cada sessão atinge um de sete estados claros, para que o seu código saiba sempre o que fazer:
Approved, todas as verificações passaram. Avance com o utilizador.Declined, uma ou mais verificações falharam. Pode permitir que o utilizador reenvie o passo específico que falhou (por exemplo, tirar novamente a selfie) sem ter de executar todo o fluxo novamente.In Review, sinalizado para revisão de conformidade. Abra o caso na consola, veja todos os sinais, decida aprovar ou recusar.In Progress, o utilizador está a meio do fluxo.Not Started, link enviado, o utilizador ainda não o abriu. Envie um lembrete se demorar muito.Abandoned, o utilizador abriu o link mas não terminou a tempo. Reengaje ou expire.Expired, o link da sessão expirou. Crie uma nova sessão.Um webhook assinado é acionado em cada mudança de estado, para que a sua base de dados esteja sempre sincronizada. As sessões abandonadas e recusadas são gratuitas.
Os dados de produção são processados e armazenados na União Europeia por defeito, na Amazon Web Services. Contratos empresariais podem solicitar regiões alternativas para jurisdições cujos reguladores o exijam.
Criptografia em todo o lado. AES-256 em repouso em todas as bases de dados, armazenamento de objetos e backups. Transport Layer Security 1.3 em trânsito em cada chamada de API, webhook e sessão da Consola de Negócios. Os dados biométricos são criptografados sob uma Customer Master Key separada.
A retenção é sua para controlar. A retenção padrão é indefinida (ilimitada), a menos que configure um período mais curto, entre 30 dias e 10 anos por aplicação, e pode eliminar qualquer sessão individual a qualquer momento a partir do dashboard ou da API.
Certificações: SOC 2 Tipo 1 (auditoria Tipo 2 em curso), ISO/IEC 27001:2022, iBeta Nível 1 PAD, e uma atestação pública do Tesoro / SEPBLAC / CNMV de Espanha de que a verificação remota de identidade da Didit é mais segura do que verificar alguém presencialmente. Relatório completo em /security-compliance.
A Didit está em conformidade por defeito com os reguladores relevantes para a infraestrutura de identidade:
Memorando detalhado, todos os certificados, todas as cartas regulatórias: /security-compliance.
Três caminhos de integração, escolha o que melhor se adapta à sua stack:
Mesmo dashboard, mesma faturação, mesmo preço pay-per-success para os três. Guia passo a passo em docs.didit.me/integration/integration-prompt.
Uma API para KYC, KYB, Monitorização de Transações e Rastreio de Carteiras. Integre em 5 minutos.