> ## 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 credenciais Didit: obter client_id e api_key

> Faça GET do client_id e da api_key da sua aplicação Didit. Use a api_key no cabeçalho x-api-key nas APIs de verificação. Pague por uso.



Prompt para obter as credenciais da aplicação
        Copiar o prompt para a área de transferência



      
      

\<pre>

\`Read one application's full record — including its client_id and api_key (client_secret). Use this to RECOVER an api_key you've misplaced.

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

Authentication:
Authorization: Bearer <access_token>
Get a token via POST /programmatic/login/.

Path parameters:
\- org_id (UUID, required) — Organization that owns the application. Get via GET /organizations/me/.
\- app_id (UUID, required) — Application UUID. Returned by POST /programmatic/verify-email/ (in the application.uuid field), by POST /organizations/me/{org_id}/applications/, or visible in the Didit console.

curl example:
curl "https://apx.didit.me/auth/v2/organizations/me/<ORG_ID>/applications/<APP_ID>/" \
-H "Authorization: Bearer <ACCESS_TOKEN>"

Response (200 OK):
\{
"uuid": "b2c3d4e5-6789-...",
"name": "My App",
"client_id": "S9LIYGSoWNuGMLHsvEt9dQ",
"api_key": "sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"website_url": "https://example.com",
"redirect_uris": ["https://example.com/callback"],
"terms_url": "https://example.com/terms",
"privacy_url": "https://example.com/privacy",
"description": "Production application",
"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": {} }
]
}

How to use the response:
\- api_key → set as the x-api-key header on EVERY call to https://verification.didit.me/v3/... (sessions, workflows, questionnaires, AML monitoring, billing, etc.).
\- client_id → shown alongside api_key for OAuth-style introspection scenarios. Routine verification calls only need api_key.
\- products → read-only. Always all three products in this order: identity, transactions, authentication. Each has a status (enabled, early_access or disabled) and its module switches (true or false). identity modules: user_verification, business_verification, case_management. transactions modules: travel_rule, case_management. authentication has none ({}).

Failure modes:
\- 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, or { "detail": "Application not found." } when the application is not in that organization.

When to call:
\- After programmatic login from a new machine — you have an access_token but not the api_key, and you need x-api-key to start calling verification.didit.me.
\- Auditing your applications — list all apps with GET /organizations/me/{org_id}/applications/, then read each.

Note:
This endpoint does not rotate the credential. It returns the application's current api_key on every GET, so there is no "show api_key once" model.

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

\</pre>



      
      

Colar em



## OpenAPI

````yaml pt-br/openapi-auth.json GET /organizations/me/{org_id}/applications/{app_id}/
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/{app_id}/:
    get:
      tags:
        - Account Management
      summary: Obter as credenciais da aplicação
      description: >-
        Lê o registro completo de uma aplicação, incluindo `client_id` e
        `api_key`. Use para recuperar uma `api_key` perdida.
      operationId: get_application_credentials
      parameters:
        - name: org_id
          in: path
          required: true
          description: UUID da organização proprietária da aplicação.
          schema:
            type: string
            format: uuid
            example: a1b2c3d4-5678-90ab-cdef-111111111111
        - name: app_id
          in: path
          required: true
          description: UUID da aplicação cujas credenciais você quer ler.
          schema:
            type: string
            format: uuid
            example: b2c3d4e5-6789-01bc-defg-222222222222
      responses:
        '200':
          description: Registro da aplicação, incluindo seu `client_id` e sua `api_key`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Application'
              examples:
                Success:
                  value:
                    uuid: b2c3d4e5-6789-01bc-defg-222222222222
                    name: My App
                    client_id: S9LIYGSoWNuGMLHsvEt9dQ
                    api_key: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
                    website_url: https://example.com
                    redirect_uris:
                      - https://example.com/callback
                    terms_url: https://example.com/terms
                    privacy_url: https://example.com/privacy
                    description: Production application
                    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: {}
        '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 ler esta aplicaçã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.`
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AuthError'
              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.
        '404':
          description: >-
            A organização não existe ou você não é membro dela, ou a aplicação
            não existe nessa organização.
          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.
                ApplicationNotFound:
                  summary: Aplicação não encontrada nesta organização
                  value:
                    detail: Application not found.
      security:
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: >-
            curl
            "https://apx.didit.me/auth/v2/organizations/me/$ORG_ID/applications/$APP_ID/"
            \
              -H "Authorization: Bearer $ACCESS_TOKEN"
        - 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.retrieve(
                "a1b2c3d4-5678-90ab-cdef-111111111111",
                "b2c3d4e5-6789-01bc-defg-222222222222",
            )
            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.retrieve(
              "a1b2c3d4-5678-90ab-cdef-111111111111",
              "b2c3d4e5-6789-01bc-defg-222222222222",
            );
            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.Retrieve(ctx, \"a1b2c3d4-5678-90ab-cdef-111111111111\", \"b2c3d4e5-6789-01bc-defg-222222222222\")\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;


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

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


            var result =
            client.account().applications().retrieve("a1b2c3d4-5678-90ab-cdef-111111111111",
            "b2c3d4e5-6789-01bc-defg-222222222222");

            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->retrieve('a1b2c3d4-5678-90ab-cdef-111111111111',
            'b2c3d4e5-6789-01bc-defg-222222222222');

            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.retrieve(
              "a1b2c3d4-5678-90ab-cdef-111111111111",
              "b2c3d4e5-6789-01bc-defg-222222222222"
            )
            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.RetrieveAsync("a1b2c3d4-5678-90ab-cdef-111111111111",
            "b2c3d4e5-6789-01bc-defg-222222222222");

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    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: {}
    AuthError:
      type: object
      description: Envelope de erro de autenticação / autorização / não encontrado.
      properties:
        detail:
          type: string
          example: Invalid access token
    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.