> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# API de criação de aplicações: apps via programação

> POST /organizations/me/{org_id}/applications/ cria uma aplicação Didit por cliente, marca, ambiente ou área de negócio. Retorna client_id e api_key.



Prompt para criar aplicação
        Copiar o prompt para a área de transferência



      
      

\<pre>

\`Create a new Didit application inside one of your organizations — each application has its own client_id and api_key, isolating sessions, webhooks, branding, and billing from sibling applications.

Endpoint:
POST https://apx.didit.me/auth/v2/organizations/me/{org_id}/applications/

Authentication:
Authorization: Bearer <access_token>
The access token must belong to an OWNER or ADMIN of the target organization. Get one via POST /programmatic/login/ or POST /programmatic/verify-email/.

Path parameter:
\- org_id (UUID, required) — Organization that will own the new application. Discover yours via GET /organizations/me/.

Request body (ALL fields optional — omit the body to get a default-named app):
\- name (string, optional) — Display name. Defaults to "<organization name> App".
\- website_url (string, URL, optional) — Public homepage shown in the verification flow.
\- redirect_uris (array of strings, optional) — Allowlisted OAuth-style redirect URIs.
\- terms_url (string, URL, optional) — Terms-of-service link shown in the verification UI.
\- privacy_url (string, URL, optional) — Privacy policy link shown in the verification UI.
\- description (string, optional) — Internal note. Not shown to end users.

When to call:
\- Resellers — one application per end customer to fully isolate credentials, branding, webhooks, and billing.
\- Multi-brand / multi-product — one application per brand, product, region, or environment (dev / staging / prod).
\- Use-case separation — e.g. one application for ID + selfie KYC, another for AML screening only.

curl example:
curl -X POST "https://apx.didit.me/auth/v2/organizations/me/<ORG_ID>/applications/" \
-H "Authorization: Bearer <ACCESS_TOKEN>" \
-H "Content-Type: application/json" \
-d '{
"name": "Acme Customer App",
"website_url": "https://acme.example",
"redirect_uris": ["https://acme.example/callback"],
"terms_url": "https://acme.example/terms",
"privacy_url": "https://acme.example/privacy"
}'

Response (201 Created):
\{
"uuid": "b2c3d4e5-6789-...",
"name": "Acme Customer App",
"client_id": "S9LIYGSoWNuGMLHsvEt9dQ",
"api_key": "sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"website_url": "https://acme.example",
"redirect_uris": ["https://acme.example/callback"],
"terms_url": "https://acme.example/terms",
"privacy_url": "https://acme.example/privacy",
"description": null,
"created_at": "2025-06-01T10:00:00Z",
"products": [
\{ "product": "identity", "status": "enabled", "modules": { "user_verification": true, "business_verification": true, "case_management": true } },
\{ "product": "transactions", "status": "disabled", "modules": { "travel_rule": true, "case_management": true } },
\{ "product": "authentication", "status": "disabled", "modules": {} }
]
}

What to do with the response:
\- PERSIST api_key SECURELY — use it as the x-api-key header on every https://verification.didit.me/v3/... call (sessions, workflows, billing).
\- Persist uuid (app_id) — required for /organizations/me/{org_id}/applications/{app_id}/ reads and updates.
\- If you lose the api_key, recover it later via GET /organizations/me/{org_id}/applications/{app_id}/ — see /auth-api/get-credentials.
\- products is read-only and always lists identity, transactions and authentication in that order. A new application has identity enabled with every module on, and transactions and authentication disabled. A products key in the request body is ignored.

Failure modes:
\- 400 — { "<field>": ["Enter a valid URL."] } for malformed website_url / redirect_uris / terms_url / privacy_url.
\- 401: { "detail": "Invalid access token" } or { "detail": "Expired access token" } when the token is malformed or expired.
\- 403: { "detail": "Only organization owners and admins can manage applications." } when you are a member of the organization but not an owner or admin.
\- 403: { "detail": "Your access to this organization is suspended." } when your membership in the organization is suspended.
\- 403: { "detail": "You do not have permission to perform this action." } when the request has no Authorization header.
\- 404: { "detail": "Organization not found." } when the organization does not exist or you are not a member of it.

Next steps:
\- Configure a workflow inside the new application via POST /v3/workflows/ — see /management-api/workflows/create.
\- Update application metadata later via PATCH /organizations/me/{org_id}/applications/{app_id}/ — see /auth-api/update-application.

For end-to-end Didit integration, paste in the full prompt at /integration/integration-prompt.`

\</pre>



      
      

Colar em

Use este endpoint quando você precisar separar tráfego de verificação, credenciais, identidade visual ou relatórios dentro da mesma organização.Isso é especialmente útil para **revendedores** que criam uma aplicação por cliente. Também funciona bem quando a sua própria empresa tem vários produtos, marcas, regiões, ambientes de staging/produção ou casos de uso que não devem compartilhar a mesma chave de API nem as mesmas configurações no nível da aplicação.> [!NOTE]
>
> Todos os endpoints da Auth API usam `https://apx.didit.me/auth/v2`. Use a `api_key` retornada como `x-api-key` ao chamar endpoints `https://verification.didit.me/v3/...`, como os de sessões e fluxos.


## OpenAPI

````yaml pt-br/openapi-auth.json POST /organizations/me/{org_id}/applications/
openapi: 3.0.0
info:
  version: 1.0.0
  title: Didit Auth API
  description: >-
    API de registro e autenticação programáticos para desenvolvedores e agentes
    de IA. Registre-se em 2 chamadas de API, sem precisar de navegador. A
    plataforma de verificação de identidade mais amigável para agentes.


    ## URL base


    Todos os endpoints desta especificação ficam hospedados em
    `https://apx.didit.me/auth/v2`. Esse host é diferente do host da API de
    verificação (`https://verification.didit.me/v3`). Não confunda os dois: este
    host de autenticação emite seus **tokens de acesso JWT** e permite listar e
    gerenciar suas **organizações** e **aplicações**. O host de verificação é
    onde você chama sessões, fluxos, AML etc., autenticando-se com a
    **`api_key`** retornada por esta API.


    ## Como funciona o fluxo de autenticação


    1. `POST /programmatic/register/`: envie e-mail + senha.

    2. Receba por e-mail um código alfanumérico de 6 caracteres.

    3. `POST /programmatic/verify-email/`: envie o código. Você recebe um
    `access_token` JWT, um `refresh_token`, uma organização e uma aplicação
    padrão com `client_id` + `api_key`.

    4. Guarde a `api_key`. Use-a como `x-api-key` em todas as chamadas para
    `https://verification.didit.me/v3/...`.

    5. Em qualquer máquina, no futuro, `POST /programmatic/login/` troca seu
    e-mail + senha por um JWT novo; depois chame `GET /organizations/me/` e os
    endpoints de aplicação para recuperar ou rotacionar credenciais.


    O JWT só é necessário para os endpoints de **Account Management** desta
    especificação; o tráfego da API de verificação usa a `api_key` de longa
    duração, não o JWT.


    ## Convenções


    - Todos os corpos de requisição e resposta são JSON (`Content-Type:
    application/json`).

    - **Use um endereço de e-mail real, que receba mensagens, ao testar `POST
    /programmatic/register/`.** O endpoint envia o código de verificação de
    forma síncrona, então endereços em domínios de teste reservados
    (`@example.com`, `@example.org`, `@*.test`, `@*.example`, `@*.invalid`) são
    recusados pela entrega de e-mail e a requisição retorna `500`. Substitua o
    placeholder `you@yourdomain.com` dos exemplos por uma caixa de entrada que
    você consiga ler de fato.

    - Erros de validação retornam HTTP `400` com um de dois envelopes:
    `{"field": ["message", ...]}` para problemas em nível de campo, ou
    `{"detail": "message"}` para erros de regra de negócio. Alguns validadores
    (força da senha no registro, expiração do código no verify-email) respondem
    atualmente com um array simples `["message"]` em vez do formato indexado por
    campo. Trata-se de uma inconsistência conhecida do lado do servidor, então o
    código do cliente deve aceitar os dois formatos.

    - Erros de autenticação retornam como `{"detail": "..."}` com HTTP `401`
    (bearer token inválido) ou `403` (bearer token ausente / privilégios
    insuficientes).

    - Respostas de limite de requisições incluem um campo `wait` com o tempo de
    espera em segundos.
servers:
  - url: https://apx.didit.me/auth/v2
    description: Servidor de autenticação de produção
security: []
tags:
  - name: Programmatic Auth
    description: >-
      Ciclo de vida da conta com e-mail e senha: registro, verificação e login.
      Retorna o `access_token` JWT que você usa nos endpoints de gerenciamento
      de conta, além (na verificação) do `client_id` e da `api_key` da sua
      primeira aplicação.
  - name: Account Management
    description: >-
      Endpoints autenticados (JWT bearer) que listam organizações e criam,
      consultam ou atualizam aplicações. Use-os para recuperar ou rotacionar a
      `api_key` com a qual você autentica as chamadas da API de verificação.
paths:
  /organizations/me/{org_id}/applications/:
    post:
      tags:
        - Account Management
      summary: Criar aplicação
      description: >-
        Cria uma aplicação dentro de uma organização. A resposta inclui
        `api_key`; armazene-a agora (pode ser recuperada via GET). Requer um JWT
        de proprietário/administrador.
      operationId: create_organization_application
      parameters:
        - name: org_id
          in: path
          required: true
          description: UUID da organização. Consulte-o com `GET /organizations/me/`.
          schema:
            type: string
            format: uuid
            example: a1b2c3d4-5678-90ab-cdef-111111111111
      requestBody:
        required: false
        description: >-
          Todos os campos são opcionais. Omitir o corpo cria uma aplicação com o
          nome padrão `"<organization name> App"` e sem URLs públicas
          configuradas.
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ApplicationCreateRequest'
            examples:
              ResellerCustomer:
                summary: Revendedor criando uma aplicação vinculada a um cliente
                value:
                  name: Acme Customer App
                  website_url: https://acme.example
                  redirect_uris:
                    - https://acme.example/callback
                  terms_url: https://acme.example/terms
                  privacy_url: https://acme.example/privacy
              Minimal:
                summary: Criação mínima -- aceitar todos os valores padrão
                value:
                  name: Sandbox App
              Empty:
                summary: Nenhum corpo -- o padrão é <nome da organização> App
                value: {}
      responses:
        '201':
          description: >-
            Aplicação criada. A resposta inclui a `api_key` de longa duração.
            Guarde-a agora e use-a como cabeçalho `x-api-key` em todas as
            chamadas a `https://verification.didit.me/v3/...`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
              examples:
                Success:
                  value:
                    uuid: b2c3d4e5-6789-01bc-defg-222222222222
                    name: Acme Customer App
                    client_id: S9LIYGSoWNuGMLHsvEt9dQ
                    api_key: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
                    website_url: https://acme.example
                    redirect_uris:
                      - https://acme.example/callback
                    terms_url: https://acme.example/terms
                    privacy_url: https://acme.example/privacy
                    description: null
                    created_at: '2025-06-01T10:00:00Z'
                    products:
                      - product: identity
                        status: enabled
                        modules:
                          user_verification: true
                          business_verification: true
                          case_management: true
                      - product: transactions
                        status: disabled
                        modules:
                          travel_rule: true
                          case_management: true
                      - product: authentication
                        status: disabled
                        modules: {}
        '400':
          description: >-
            Erro de validação no corpo da requisição (por exemplo, uma URI de
            redirecionamento malformada).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationError'
              examples:
                InvalidUrl:
                  value:
                    website_url:
                      - Enter a valid URL.
        '401':
          description: >-
            Token de acesso malformado, inválido ou expirado. Obtenha um novo
            com `POST /programmatic/login/`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AuthError'
              examples:
                InvalidToken:
                  value:
                    detail: Invalid access token
                ExpiredToken:
                  value:
                    detail: Expired access token
        '403':
          description: >-
            Você não pode criar aplicações nesta organização. Um membro da
            organização que não seja proprietário nem administrador recebe `Only
            organization owners and admins can manage applications.` Um
            proprietário ou administrador cujo acesso à organização esteja
            suspenso recebe `Your access to this organization is suspended.` Uma
            requisição sem o cabeçalho `Authorization` recebe `You do not have
            permission to perform this action.` Durante 72 horas após a
            recuperação da sua conta, a requisição é recusada com `code`
            `recovery_hold` e `until`, o horário em que o bloqueio termina.
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/AuthError'
                  - $ref: '#/components/schemas/RecoveryHoldError'
              examples:
                NotOwnerOrAdmin:
                  summary: Membro que não é proprietário nem administrador
                  value:
                    detail: >-
                      Only organization owners and admins can manage
                      applications.
                Suspended:
                  summary: Associação suspensa
                  value:
                    detail: Your access to this organization is suspended.
                MissingToken:
                  summary: Nenhum cabeçalho Authorization
                  value:
                    detail: You do not have permission to perform this action.
                RecoveryHold:
                  summary: Conta recuperada há menos de 72 horas
                  value:
                    detail: This action is on hold because you recovered your account.
                    code: recovery_hold
                    until: '2026-11-04T10:15:00+00:00'
        '404':
          description: A organização não existe ou você não é membro dela.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AuthError'
              examples:
                OrganizationNotFound:
                  summary: Organização não encontrada, ou você não é membro
                  value:
                    detail: Organization not found.
      security:
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: >-
            curl -X POST
            "https://apx.didit.me/auth/v2/organizations/me/$ORG_ID/applications/"
            \
              -H "Authorization: Bearer $ACCESS_TOKEN" \
              -H "Content-Type: application/json" \
              -d '{
                "name": "Acme Customer App",
                "website_url": "https://acme.example",
                "redirect_uris": ["https://acme.example/callback"]
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Use the access token that account.login returns.
            client = Didit(account_token="YOUR_ACCESS_TOKEN")

            result = client.account.applications.create(
                "a1b2c3d4-5678-90ab-cdef-111111111111",
                name="Acme Customer App",
                website_url="https://acme.example",
                redirect_uris=["https://acme.example/callback"],
                terms_url="https://acme.example/terms",
                privacy_url="https://acme.example/privacy",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: >-
            import Didit from "@didit-protocol/sdk-node";


            // Use the access token that account.login returns.

            const didit = new Didit({ accountToken: "YOUR_ACCESS_TOKEN" });


            const result = await
            didit.account.applications.create("a1b2c3d4-5678-90ab-cdef-111111111111",
            {
              name: "Acme Customer App",
              website_url: "https://acme.example",
              redirect_uris: ["https://acme.example/callback"],
              terms_url: "https://acme.example/terms",
              privacy_url: "https://acme.example/privacy",
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Use the access token that account.login returns.\nclient := didit.NewClient(option.WithAccountToken(\"YOUR_ACCESS_TOKEN\"))\n\nresult, err := client.Account.Applications.Create(ctx, \"a1b2c3d4-5678-90ab-cdef-111111111111\", didit.ApplicationCreateRequest{\n\tName:         didit.String(\"Acme Customer App\"),\n\tWebsiteURL:   didit.String(\"https://acme.example\"),\n\tRedirectURIs: didit.Some([]string{\"https://acme.example/callback\"}),\n\tTermsURL:     didit.String(\"https://acme.example/terms\"),\n\tPrivacyURL:   didit.String(\"https://acme.example/privacy\"),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.ApplicationCreateRequest;


            // Use the access token that account.login returns.

            Didit client =
            Didit.builder().accountToken("YOUR_ACCESS_TOKEN").build();


            var result =
            client.account().applications().create("a1b2c3d4-5678-90ab-cdef-111111111111",
            ApplicationCreateRequest.builder()
                    .name("Acme Customer App")
                    .websiteUrl("https://acme.example")
                    .redirectUris(List.of("https://acme.example/callback"))
                    .termsUrl("https://acme.example/terms")
                    .privacyUrl("https://acme.example/privacy")
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Use the access token that account.login returns.

            $didit = new DiditClient(accountToken: 'YOUR_ACCESS_TOKEN');


            $result =
            $didit->account->applications->create('a1b2c3d4-5678-90ab-cdef-111111111111',
            [
                'name' => 'Acme Customer App',
                'website_url' => 'https://acme.example',
                'redirect_uris' => ['https://acme.example/callback'],
                'terms_url' => 'https://acme.example/terms',
                'privacy_url' => 'https://acme.example/privacy',
            ]);

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Use the access token that account.login returns.
            didit = Didit::Client.new(account_token: "YOUR_ACCESS_TOKEN")

            result = didit.account.applications.create(
              "a1b2c3d4-5678-90ab-cdef-111111111111",
              name: "Acme Customer App",
              website_url: "https://acme.example",
              redirect_uris: ["https://acme.example/callback"],
              terms_url: "https://acme.example/terms",
              privacy_url: "https://acme.example/privacy"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Use the access token that account.login returns.

            using var client = new DiditClient(new DiditClientOptions {
            AccountToken = "YOUR_ACCESS_TOKEN" });


            var result = await
            client.Account.Applications.CreateAsync("a1b2c3d4-5678-90ab-cdef-111111111111",
            new ApplicationCreateRequest

            {
                Name = "Acme Customer App",
                WebsiteUrl = "https://acme.example",
                RedirectUris = new string[] { "https://acme.example/callback" },
                TermsUrl = "https://acme.example/terms",
                PrivacyUrl = "https://acme.example/privacy",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    ApplicationCreateRequest:
      type: object
      description: >-
        Todos os campos são opcionais. Enviar um corpo vazio cria uma aplicação
        com um nome padrão.
      properties:
        name:
          type: string
          description: >-
            Nome de exibição da aplicação. O padrão é `"<organization name>
            App"`.
          example: Acme Customer App
        website_url:
          type: string
          description: URL do site ou do app associado a esta aplicação.
          example: https://acme.example
        redirect_uris:
          type: array
          items:
            type: string
          description: >-
            URIs de redirecionamento permitidas para fluxos de redirecionamento
            no estilo OAuth e de verificação.
          example:
            - https://acme.example/callback
        terms_url:
          type: string
          description: URL dos termos de serviço exibida no fluxo de verificação.
          example: https://acme.example/terms
        privacy_url:
          type: string
          description: URL da política de privacidade exibida no fluxo de verificação.
          example: https://acme.example/privacy
        description:
          type: string
          description: Descrição interna da aplicação (não exibida aos usuários finais).
    Application:
      type: object
      description: >-
        Registro completo da aplicação. `uuid`, `client_id` e `api_key` nunca
        mudam após a criação.
      properties:
        uuid:
          type: string
          format: uuid
          description: UUID da aplicação. Use como `{app_id}` nas chamadas seguintes.
          example: b2c3d4e5-6789-01bc-defg-222222222222
        name:
          type: string
          description: Nome de exibição da aplicação mostrado no console da Didit.
          example: Acme Production App
        client_id:
          type: string
          description: >-
            Identificador público do cliente, seguro para incorporar em fluxos
            no estilo OAuth.
          example: S9LIYGSoWNuGMLHsvEt9dQ
        api_key:
          type: string
          description: >-
            Segredo de longa duração (também chamado de `client_secret`). Use-o
            como cabeçalho `x-api-key` em todas as chamadas a
            `https://verification.didit.me/v3/...` (sessões, fluxos de
            verificação (workflows), AML etc.). Trate-o como uma credencial;
            nunca o exponha no lado do cliente. Novas chaves começam com
            `sk_live_` (aplicação de produção) ou `sk_test_` (aplicação
            sandbox), seguidos de 43 caracteres seguros para URL (letras,
            dígitos, `-` e `_`). Chaves criadas antes desse formato não têm
            prefixo e continuam funcionando sem alterações. Durante 72 horas
            após a recuperação da sua conta, as operações de listar, obter e
            atualizar retornam uma string vazia aqui em vez da chave.
          example: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        website_url:
          type: string
          nullable: true
          description: URL do site ou do app associado a esta aplicação.
          example: https://acme.example
        redirect_uris:
          type: array
          items:
            type: string
          description: >-
            URIs de redirecionamento permitidas para fluxos de redirecionamento
            no estilo OAuth e de verificação.
          example:
            - https://acme.example/callback
        terms_url:
          type: string
          nullable: true
          description: URL dos termos de serviço exibida no fluxo de verificação.
          example: https://acme.example/terms
        privacy_url:
          type: string
          nullable: true
          description: URL da política de privacidade exibida no fluxo de verificação.
          example: https://acme.example/privacy
        description:
          type: string
          nullable: true
          description: Descrição interna da aplicação (não exibida aos usuários finais).
        created_at:
          type: string
          format: date-time
          example: '2025-06-01T10:00:00Z'
        products:
          type: array
          readOnly: true
          description: >-
            Os produtos da aplicação. Sempre os três, nesta ordem: `identity`,
            `transactions`, `authentication`. Uma nova aplicação tem `identity`
            habilitado com todos os módulos ativos, e `transactions` e
            `authentication` desabilitados. Somente leitura: uma chave
            `products` no corpo de criação ou atualização é ignorada.
          items:
            $ref: '#/components/schemas/ApplicationProduct'
          example:
            - product: identity
              status: enabled
              modules:
                user_verification: true
                business_verification: true
                case_management: true
            - product: transactions
              status: disabled
              modules:
                travel_rule: true
                case_management: true
            - product: authentication
              status: disabled
              modules: {}
    ValidationError:
      description: >-
        Corpo do erro de validação. O envelope previsto é um mapa `{field:
        ["message", ...]}` para erros no nível de campo ou um envelope de chave
        única `{detail: "..."}` para erros de regra de negócio. Alguns
        validadores (força da senha no cadastro, validade do código na
        verificação de e-mail) atualmente respondem com um array simples
        `["message"]`, uma inconsistência conhecida no servidor. O schema abaixo
        mantém essa ramificação de array simples para que o código de cliente
        gerado a partir desta especificação desserialize as respostas atuais,
        mas o novo código de cliente deve tratá-la como a forma correspondente
        com chave de campo (`{password: [...]}` ou `{code: [...]}`), e o
        contrato do servidor vai convergir para esse formato.
      oneOf:
        - type: object
          additionalProperties:
            type: array
            items:
              type: string
          example:
            email:
              - Enter a valid email address.
        - type: object
          properties:
            detail:
              type: string
          example:
            detail: An account with this email already exists.
        - type: array
          items:
            type: string
          example:
            - Invalid or expired verification code.
    AuthError:
      type: object
      description: Envelope de erro de autenticação / autorização / não encontrado.
      properties:
        detail:
          type: string
          example: Invalid access token
    RecoveryHoldError:
      type: object
      description: >-
        Retornado durante 72 horas após a recuperação da conta (os métodos de
        login perdidos foram redefinidos). Ações que criam organizações,
        aplicações ou segredos são recusadas até `until`; as operações de
        leitura continuam funcionando.
      required:
        - detail
        - code
        - until
      properties:
        detail:
          type: string
          example: This action is on hold because you recovered your account.
        code:
          type: string
          enum:
            - recovery_hold
          example: recovery_hold
        until:
          type: string
          format: date-time
          description: >-
            Quando o bloqueio termina (ISO 8601). Tente a requisição novamente
            após esse horário.
          example: '2026-11-04T10:15:00+00:00'
    ApplicationProduct:
      type: object
      description: >-
        Um produto de uma aplicação e seu estado. Somente leitura: os endpoints
        de aplicação o retornam e o ignoram no corpo de uma requisição.
      properties:
        product:
          type: string
          enum:
            - identity
            - transactions
            - authentication
          description: >-
            `identity` (Verificação de identidade), `transactions`
            (Monitoramento de transações) ou `authentication` (Autenticação).
          example: identity
        status:
          type: string
          enum:
            - enabled
            - early_access
            - disabled
          description: >-
            Se o produto está ativado para esta aplicação. `early_access` se
            aplica somente a `authentication`, que a Didit ativa para você.
          example: enabled
        modules:
          type: object
          additionalProperties:
            type: boolean
          description: >-
            Chaves de ativação dos módulos do produto, cada uma `true` ou
            `false`. `identity` tem `user_verification`, `business_verification`
            e `case_management`. `transactions` tem `travel_rule` e
            `case_management`. `authentication` não tem nenhuma (`{}`).
            `case_management` é uma única configuração exibida tanto em
            `identity` quanto em `transactions`, portanto tem o mesmo valor em
            ambos.
          example:
            user_verification: true
            business_verification: true
            case_management: true
      required:
        - product
        - status
        - modules
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        JWT `access_token` assinado com RS256, retornado por `POST
        /programmatic/login/` ou `POST /programmatic/verify-email/`. Envie como
        `Authorization: Bearer <access_token>`. A validade padrão é de 86400
        segundos (24h). Este token só é válido nos endpoints de Account
        Management em `apx.didit.me/auth/v2`. A API de verificação
        (`verification.didit.me/v3`) usa, em vez disso, a `api_key` de longa
        duração como `x-api-key`.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.