> ## 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.

# Obter chaves de assinatura (JWKS) | API Didit

> GET /.well-known/jwks.json retorna as chaves públicas ES256 da sua aplicação Didit. Cache por kid; rotação a cada 30 dias, sobreposição de um dia.

> [!WARNING]
>
> A autenticação é um recurso novo. Esses endpoints são servidos pelo emissor da sua aplicação, como `https://<name>.auth.didit.me`, e nunca recebem sua chave de API da Didit.

As chaves são rotacionadas a cada 30 dias, com um dia de sobreposição de cada lado, então um JWKS armazenado em cache por 5 minutos continua permitindo a verificação durante uma rotação. Busque-o novamente quando um token indicar um `kid` que você não tem, no máximo uma vez por minuto. Consulte [Cache e rotação](https://docs.didit.me/pt-br/authentication/tokens-and-jwks.md#cache-e-rotação).


## OpenAPI

````yaml pt-br/openapi-authentication.json GET /.well-known/jwks.json
openapi: 3.0.3
info:
  title: Didit Authentication API
  version: 1.0.0
  description: >-
    Os endpoints voltados ao servidor do Didit Authentication, o produto de
    login para os usuários finais da sua aplicação. O Authentication é **novo**
    e chega à produção na versão de 2026-11-01.


    ## URL base


    Cada aplicação é o seu próprio emissor OpenID Connect, e todos os endpoints
    abaixo são servidos na raiz desse emissor:


    - `https://<name>.auth.didit.me` para uma aplicação de produção, ou
    `https://<name>.sandbox.auth.didit.me` para uma aplicação de sandbox.

    - O seu próprio domínio personalizado, depois de ativado. Ele passa então a
    substituir o host padrão como emissor: novos tokens o indicam em `iss`, o
    discovery aponta para ele e a chave publicável muda. Tokens de acesso
    emitidos sob o host padrão falham em `/session/`, `/step-up/` e
    `/monitoring-token/` até serem renovados.


    Produção e sandbox são aplicações separadas, portanto são emissores
    separados, com chaves separadas. A chave publicável é `pk_live_` (produção)
    ou `pk_test_` (sandbox) seguida da codificação base64url sem preenchimento
    do emissor, sem barra final: decodifique-a para descobrir o emissor. Ela é
    um identificador público, não uma credencial.


    Os mesmos endpoints JSON também são servidos em
    `https://apx.didit.me/auth/v2/authentication/{application_id}/`. Os tokens
    sempre indicam o emissor acima, seja qual for o endereço que os emitiu.


    ## Credenciais


    Estes endpoints nunca recebem a sua chave de API do Didit nem um token do
    console.


    - O discovery, o JWKS e `POST /token/` não recebem credencial. Os clientes
    são públicos: não há client secret, e um código de autorização fica
    vinculado ao seu verificador PKCE (`S256`). O `client_id` é o ID da sua
    aplicação.

    - `/session/`, `/step-up/` e `/monitoring-token/` recebem o token de acesso
    da pessoa: `Authorization: Bearer <access_token>`. Cada chamada bem-sucedida
    conta como atividade na sessão, então reinicia o tempo limite de inatividade
    da sessão.


    ## Corpos de requisição


    Todo endpoint que recebe um corpo aceita corpos JSON, form-encoded e
    multipart. Este documento lista JSON, além de form-encoded para `POST
    /token/`, como os clientes OAuth o enviam. Um campo que o endpoint não
    aceita recebe `400 {"<field>": "unknown_field"}`.


    ## Tokens


    - **Token de acesso**: um JWT ES256 com o cabeçalho `typ: at+jwt`, válido
    por no máximo 5 minutos e nunca por mais tempo que a sua sessão. Claims:
    `AccessTokenClaims`.

    - **ID token**: um JWT ES256 com o cabeçalho `typ: JWT`. Claims:
    `IDTokenClaims`. Ele nunca é aceito como token de acesso.

    - **Refresh token**: uma string aleatória que é rotacionada a cada uso.
    Enviar novamente um refresh token já usado revoga a sessão.


    Verifique um token com as chaves de `GET /.well-known/jwks.json`: o
    algoritmo deve ser `ES256`, `typ` deve corresponder ao tipo de token, `iss`
    deve ser igual ao emissor que você configurou e `aud` ao ID da sua
    aplicação. A verificação offline só percebe uma sessão revogada quando o
    token de acesso dela expira; `GET /session/` é a verificação instantânea.


    ## Erros


    | Corpo | Quando |

    | --- | --- |

    | `{"error": "<code>"}` | Erros de `POST /token/`, todos com status `400`,
    no formato de corpo da [RFC 6749, seção
    5.2](https://www.rfc-editor.org/rfc/rfc6749#section-5.2): `invalid_grant`,
    `invalid_client` e o `mfa_required` do Didit. Erros de serviço:
    `temporarily_unavailable`, `monitoring_unavailable`, `monitoring_disabled`.
    |

    | `{"<field>": ["<message>"]}` ou `{"<field>": "<code>"}` | Um campo da
    requisição falhou na validação. `non_field_errors` indica uma regra que
    envolve vários campos, e `unknown_field`, um campo que o endpoint não
    aceita. |

    | `{"detail": "<message>"}` | `401` (`invalid_token`), `403`
    (`origin_not_allowed`), `404` (aplicação ou step-up desconhecidos) e `429`
    (limite de requisições). Também `400` para um corpo que não pode ser
    interpretado (`JSON parse error - ...`), `405` para um método que o endpoint
    não atende e `415` para um `Content-Type` não suportado. |


    Um `401` também traz `WWW-Authenticate: Bearer`, e um `429` traz
    `Retry-After` em segundos.


    Duas recusas não são JSON. Um endereço que não é um emissor é recusado antes
    de chegar a estes endpoints, por exemplo com um `404` vazio para um nome
    `*.auth.didit.me` não utilizado. Um `step_up_id` que não é um UUID recebe
    uma página `404`.


    ## Limites de requisições


    Uma requisição precisa passar por duas camadas.


    **Limites por endpoint**, contados por endereço IP do cliente, por aplicação
    e por endpoint:


    - Discovery e JWKS: 1.200 requisições por minuto e 12.000 por hora.

    - Todos os demais endpoints: 30 requisições por minuto e 300 por hora. `GET`
    e `DELETE /session/` compartilham a mesma contagem.


    Acima de um limite: `429 {"detail": "Too many requests from this IP address.
    Please wait before trying again. Expected available in 60 seconds."}`, ou
    `3600 seconds` para o limite por hora.


    **Proteção contra bots**, em todo `POST` e `DELETE`. Seus buckets são
    compartilhados por todas as requisições `POST` e `DELETE` da aplicação,
    incluindo as etapas de login hospedadas, e são reabastecidos continuamente:


    - 60 requisições por minuto por endereço IP do cliente.

    - 30 requisições por minuto por dispositivo, para requisições que
    identificam o seu dispositivo, como fazem os SDKs de navegador e nativos.

    - 1.000 requisições por minuto para a aplicação inteira, somando todos os
    endereços IP.


    Acima de um bucket: `429 {"detail": "rate_limited Expected available in N
    seconds."}` (`1 second.` quando N é 1). O bucket por IP abrange vários
    endpoints, então um único endereço que mistura chamadas de token, step-up e
    logout pode esgotá-lo antes de atingir qualquer limite por endpoint. O
    bucket da aplicação conta todos os clientes da aplicação, incluindo
    navegadores.


    As duas camadas respondem antes de o endpoint ser executado, então uma
    requisição que recebeu `429` não foi executada: tente novamente depois de
    `Retry-After`, inclusive no caso de uma renovação.


    ## Requisições do navegador


    Uma requisição que traz um cabeçalho `Origin` deve vir de uma das origens da
    própria aplicação ou de suas origens permitidas; caso contrário, recebe `403
    origin_not_allowed`. Requisições de servidor para servidor não enviam
    `Origin`.


    ## Fora do escopo deste documento


    Estas rotas atendem às páginas hospedadas, aos SDKs de navegador e nativos e
    a agentes de IA. Elas não fazem parte do contrato de servidor, e os SDKs de
    servidor não as chamam:


    - Etapas de login: `POST /authorize/`, `POST /password/`, `/email/*`,
    `/phone/*`, `/password-reset/*`, `/passkeys/*`, `/mfa/*`, `/social/*` e
    `/protection/complete/`.

    - Páginas hospedadas e callbacks: `/sign-in`, `/magic`, `/invite`, `/reset`,
    `/verify/`, `/sso/*`, `/wallet/callback/`, `/logo/` e os arquivos de
    associação de apps nativos em `/.well-known/`.

    - Acesso de agentes: `/agents/*` e `/grants/`, incluindo `GET
    /agents/session/`, a verificação em tempo real do token de acesso de um
    agente de IA. O acesso de agentes não faz parte desta versão do contrato.

    - A API de gerenciamento do console para o Authentication, que recebe
    sessões do console.


    Os eventos do Authentication ainda não são entregues como webhooks, por isso
    este documento não define nenhum webhook.
servers:
  - url: https://{issuer}
    description: 'O emissor da sua aplicação: a origem do login.'
    variables:
      issuer:
        default: your-app.auth.didit.me
        description: >-
          O host do emissor: `<name>.auth.didit.me` (produção),
          `<name>.sandbox.auth.didit.me` (sandbox) ou o seu domínio
          personalizado ativo.
security: []
tags:
  - name: Issuer
    description: Chaves de descoberta e de assinatura, para verificar tokens.
  - name: Tokens
    description: Os grants de código de autorização e de refresh.
  - name: Sessions
    description: Verifica e encerra a sessão vinculada a um token de acesso.
  - name: Step-ups
    description: Verificação antes de uma ação sensível.
  - name: Monitoring
    description: Credenciais do dispositivo para eventos de monitoramento de transações.
paths:
  /.well-known/jwks.json:
    get:
      tags:
        - Issuer
      summary: Obter as chaves de assinatura
      description: >-
        As chaves públicas ES256 da aplicação. Cada token indica sua chave no
        cabeçalho `kid`.


        As chaves são rotacionadas a cada 30 dias. A próxima chave é publicada
        um dia antes de começar a assinar, e a chave anterior continua publicada
        por um dia depois de parar, de modo que um JWKS armazenado em cache por
        até 5 minutos continua verificando durante uma rotação. Armazene as
        chaves em cache por `kid` e busque o JWKS novamente quando um token
        indicar um `kid` que você não tem, no máximo uma vez por minuto. Quando
        a Didit revoga uma chave comprometida, a chave sai deste documento
        imediatamente e `GET /session/` rejeita todos os tokens que ela assinou.
        Uma chave substituta começa a assinar imediatamente, sem o dia de
        publicação antecipada, então um JWKS armazenado em cache até 5 minutos
        antes ainda aceita a chave revogada e ainda não conhece a substituta.
      operationId: authentication_get_jwks
      responses:
        '200':
          description: As chaves publicadas.
          headers:
            Cache-Control:
              description: >-
                `public, max-age=300`: você e caches compartilhados podem manter
                uma resposta bem-sucedida por 5 minutos, o tempo de vida de um
                access token.
              schema:
                type: string
                example: public, max-age=300
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JSONWebKeySet'
              examples:
                Keys:
                  summary: Uma chave de assinatura
                  value:
                    keys:
                      - kty: EC
                        crv: P-256
                        x: ZDN2unLMultuZwNY_ZKMvsKLRrlC_usPFZyK77cnDO8
                        'y': CfLKoaJNvhFpDWqG56H8dD_j0f1c93RdR63bhIdTh3I
                        kid: k_8sJ2dQvX0nLr5TfYb3HkPw
                        use: sig
                        alg: ES256
        '403':
          $ref: '#/components/responses/OriginNotAllowed'
        '404':
          $ref: '#/components/responses/ApplicationNotFound'
        '429':
          $ref: '#/components/responses/RateLimited'
        '503':
          $ref: '#/components/responses/TemporarilyUnavailable'
      security:
        - {}
components:
  schemas:
    JSONWebKeySet:
      type: object
      description: >-
        As chaves públicas de assinatura publicadas da aplicação. Normalmente
        uma chave; duas durante uma rotação, quando a próxima chave é publicada
        um dia antes de assinar e a anterior permanece publicada por um dia
        depois de parar.
      required:
        - keys
      properties:
        keys:
          type: array
          items:
            $ref: '#/components/schemas/JSONWebKey'
    JSONWebKey:
      type: object
      description: Uma chave pública P-256 no formato JWK (RFC 7517).
      required:
        - kty
        - crv
        - x
        - 'y'
        - kid
        - use
        - alg
      properties:
        kty:
          type: string
          enum:
            - EC
        crv:
          type: string
          enum:
            - P-256
        x:
          type: string
          description: A coordenada x do ponto público, em base64url.
          example: ZDN2unLMultuZwNY_ZKMvsKLRrlC_usPFZyK77cnDO8
        'y':
          type: string
          description: A coordenada y do ponto público, em base64url.
          example: CfLKoaJNvhFpDWqG56H8dD_j0f1c93RdR63bhIdTh3I
        kid:
          type: string
          description: >-
            ID da chave, o `kid` no cabeçalho de cada token que esta chave
            assina. Novos IDs de chave começam com `k_`.
          example: k_8sJ2dQvX0nLr5TfYb3HkPw
        use:
          type: string
          enum:
            - sig
        alg:
          type: string
          enum:
            - ES256
    Detail:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          example: invalid_token
    OAuthError:
      title: OAuth error
      type: object
      description: Um erro OAuth (RFC 6749, seção 5.2) ou um erro de serviço.
      required:
        - error
      properties:
        error:
          type: string
          example: invalid_grant
  responses:
    OriginNotAllowed:
      description: >-
        A requisição trouxe um `Origin` que não é o da própria aplicação nem
        está entre suas origens permitidas. Requisições de servidor não enviam
        `Origin`.
      headers:
        Cache-Control:
          description: 'Sempre `no-store`: nunca armazene esta resposta em cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Sempre `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            OriginNotAllowed:
              summary: Origem não permitida
              value:
                detail: origin_not_allowed
    ApplicationNotFound:
      description: >-
        O endereço pertence a uma aplicação, mas a Autenticação não está ativa
        para ela. No endereço `apx.didit.me`, isso indica que o ID da aplicação
        é desconhecido. Um endereço que não pertence a nenhuma aplicação é
        recusado antes de chegar ao endpoint, e essa resposta não é JSON.
      headers:
        Cache-Control:
          description: 'Sempre `no-store`: nunca armazene esta resposta em cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Sempre `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            ApplicationNotFound:
              summary: Aplicação desconhecida
              value:
                detail: No Configuration matches the given query.
    RateLimited:
      description: >-
        Muitas requisições deste endereço IP para este endpoint ou, em um `POST`
        ou `DELETE`, um bucket de proteção contra bots está vazio. Nada foi
        executado: aguarde `Retry-After` segundos e tente novamente.
      headers:
        Retry-After:
          description: Segundos de espera antes de tentar novamente.
          schema:
            type: integer
            example: 60
        Cache-Control:
          description: 'Sempre `no-store`: nunca armazene esta resposta em cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Sempre `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            RateLimited:
              summary: Limite do endpoint
              value:
                detail: >-
                  Too many requests from this IP address. Please wait before
                  trying again. Expected available in 60 seconds.
            BotProtection:
              summary: Limite de proteção contra bots (POST e DELETE)
              value:
                detail: rate_limited Expected available in 2 seconds.
    TemporarilyUnavailable:
      description: >-
        Um serviço do qual a requisição depende está temporariamente
        indisponível. Tente novamente com backoff.
      headers:
        Cache-Control:
          description: 'Sempre `no-store`: nunca armazene esta resposta em cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Sempre `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OAuthError'
          examples:
            TemporarilyUnavailable:
              summary: Tentar novamente mais tarde
              value:
                error: temporarily_unavailable

````

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