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

# Obtenir une session | API d'authentification Didit

> GET /session/ de Didit vérifie un access token en temps réel : échec immédiat après révocation, inactivité, blocage ou rafraîchissement.

> [!WARNING]
>
> L'authentification est une nouveauté. Ces endpoints sont exposés par l'émetteur de votre application, par exemple `https://<name>.auth.didit.me`, et n'acceptent jamais votre clé API Didit.

Il s'agit de la vérification de révocation instantanée. Elle autorise 30 requêtes par minute et 300 par heure, par adresse. Vérifiez donc les tokens hors ligne à chaque requête, et appelez-la avant toute action sensible. Voir [Vérifier la session](https://docs.didit.me/fr/authentication/tokens-and-jwks.md#vérifier-la-session).


## OpenAPI

````yaml fr/openapi-authentication.json GET /session/
openapi: 3.0.3
info:
  title: Didit Authentication API
  version: 1.0.0
  description: >-
    Les endpoints côté serveur de Didit Authentication, le produit de connexion
    pour les utilisateurs finaux de votre application. Authentication est
    **nouveau** et arrive en production dans la version 2026-11-01.


    ## URL de base


    Chaque application constitue son propre émetteur OpenID Connect, et chaque
    endpoint ci-dessous est servi à la racine de cet émetteur :


    - `https://<name>.auth.didit.me` pour une application en production, ou
    `https://<name>.sandbox.auth.didit.me` pour une application en sandbox.

    - Votre propre domaine personnalisé, une fois actif. Il remplace alors
    l'hôte par défaut en tant qu'émetteur : les nouveaux tokens l'indiquent dans
    `iss`, la découverte pointe vers lui et la clé publiable change. Les tokens
    d'accès émis sous l'hôte par défaut échouent sur `/session/`, `/step-up/` et
    `/monitoring-token/` tant qu'ils ne sont pas rafraîchis.


    La production et le sandbox sont des applications distinctes ; ce sont donc
    des émetteurs distincts disposant de clés distinctes. La clé publiable est
    `pk_live_` (production) ou `pk_test_` (sandbox), suivie de l'encodage
    base64url sans remplissage de l'émetteur, sans barre oblique finale :
    décodez-la pour retrouver l'émetteur. Il s'agit d'un identifiant public, pas
    d'un identifiant d'authentification.


    Les mêmes endpoints JSON sont également servis sous
    `https://apx.didit.me/auth/v2/authentication/{application_id}/`. Les tokens
    indiquent toujours l'émetteur ci-dessus, quelle que soit l'adresse qui les a
    émis.


    ## Identifiants


    Ces endpoints n'acceptent jamais votre clé API Didit ni un token de console.


    - La découverte, le JWKS et `POST /token/` ne prennent aucun identifiant.
    Les clients sont publics : il n'y a pas de secret client, et un code
    d'autorisation est lié à son vérificateur PKCE (`S256`). `client_id` est
    l'identifiant de votre application.

    - `/session/`, `/step-up/` et `/monitoring-token/` prennent le token d'accès
    de la personne : `Authorization: Bearer <access_token>`. Chaque appel réussi
    compte comme une activité sur la session, ce qui réinitialise le délai
    d'inactivité de la session.


    ## Corps de requête


    Chaque endpoint acceptant un corps prend en charge les corps au format JSON,
    au format formulaire et multipart. Ce document liste le format JSON, ainsi
    que le format encodé en formulaire pour `POST /token/` tel que les clients
    OAuth l'envoient. Un champ que l'endpoint n'accepte pas renvoie `400
    {"<field>": "unknown_field"}`.


    ## Tokens


    - **Token d'accès** : un JWT ES256 avec l'en-tête `typ: at+jwt`, valide
    pendant au maximum 5 minutes et jamais plus longtemps que sa session.
    Revendications : `AccessTokenClaims`.

    - **Token d'identification** : un JWT ES256 avec l'en-tête `typ: JWT`.
    Revendications : `IDTokenClaims`. Il n'est jamais accepté en tant que token
    d'accès.

    - **Token d'actualisation** : une chaîne aléatoire renouvelée à chaque
    utilisation. Envoyer à nouveau un token d'actualisation déjà utilisé révoque
    la session.


    Vérifiez un token à l'aide des clés provenant de `GET
    /.well-known/jwks.json` : l'algorithme doit être `ES256`, `typ` doit
    correspondre au type de token, `iss` doit être égal à l'émetteur configuré
    et `aud` à l'identifiant de votre application. La vérification hors ligne ne
    détecte une session révoquée qu'une fois son token d'accès expiré ; `GET
    /session/` constitue la vérification instantanée.


    ## Erreurs


    | Corps | Quand |

    | --- | --- |

    | `{"error": "<code>"}` | Erreurs de `POST /token/`, toutes avec le statut
    `400`, au format de corps de la [section 5.2 de la RFC
    6749](https://www.rfc-editor.org/rfc/rfc6749#section-5.2) : `invalid_grant`,
    `invalid_client` et le `mfa_required` de Didit. Erreurs de service :
    `temporarily_unavailable`, `monitoring_unavailable`, `monitoring_disabled`.
    |

    | `{"<field>": ["<message>"]}` ou `{"<field>": "<code>"}` | La validation
    d'un champ de la requête a échoué. `non_field_errors` indique une règle
    s'appliquant à plusieurs champs, et `unknown_field` un champ que l'endpoint
    n'accepte pas. |

    | `{"detail": "<message>"}` | `401` (`invalid_token`), `403`
    (`origin_not_allowed`), `404` (application inconnue ou step-up inconnu) et
    `429` (limite de débit). Également `400` pour un corps impossible à analyser
    (`JSON parse error - ...`), `405` pour une méthode que l'endpoint ne prend
    pas en charge et `415` pour un `Content-Type` non pris en charge. |


    Une réponse `401` comporte également `WWW-Authenticate: Bearer`, et une
    réponse `429` comporte `Retry-After` en secondes.


    Deux refus ne sont pas au format JSON. Une adresse qui n'est pas un émetteur
    est refusée avant d'atteindre ces endpoints, par exemple avec une erreur
    `404` vide pour un nom `*.auth.didit.me` non utilisé. Un `step_up_id` qui
    n'est pas un UUID renvoie une page `404`.


    ## Limites de débit


    Une requête doit franchir deux couches.


    **Limites par endpoint**, comptabilisées par adresse IP cliente, par
    application et par endpoint :


    - Découverte et JWKS : 1 200 requêtes par minute et 12 000 par heure.

    - Tous les autres endpoints : 30 requêtes par minute et 300 par heure. `GET`
    et `DELETE /session/` partagent le même décompte.


    En cas de dépassement de la limite : `429 {"detail": "Too many requests from
    this IP address. Please wait before trying again. Expected available in 60
    seconds."}`, ou `3600 seconds` pour la limite horaire.


    **Protection contre les bots**, sur chaque `POST` et `DELETE`. Ses
    compartiments sont partagés par toutes les requêtes `POST` et `DELETE` de
    l'application, y compris les étapes de connexion hébergées, et se
    remplissent en continu :


    - 60 requêtes par minute par adresse IP cliente.

    - 30 requêtes par minute par appareil, pour les requêtes qui identifient
    leur appareil, comme le font les SDK natifs et de navigateur.

    - 3 000 requêtes par minute pour l'ensemble de l'application, toutes
    adresses IP confondues. Les rafraîchissements de token (`POST /token/` avec
    `grant_type=refresh_token`) utilisent plutôt leur propre compartiment : 6
    000 par minute pour l'ensemble de l'application.


    En cas de dépassement d'un compartiment : `429 {"detail": "rate_limited
    Expected available in N seconds."}` (`1 second.` lorsque N vaut 1). Le
    compartiment par IP s'étend sur l'ensemble des endpoints ; ainsi, une
    adresse unique qui combine des appels de token, de step-up et de déconnexion
    peut le vider avant même d'atteindre la moindre limite par endpoint. Le
    compartiment applicatif prend en compte chaque client de l'application, y
    compris les navigateurs.


    Les deux couches répondent avant l'exécution de l'endpoint : une requête
    ayant reçu une réponse `429` n'a donc pas été exécutée. Réessayez-la après
    le délai indiqué par `Retry-After`, y compris pour un rafraîchissement.


    ## Requêtes de navigateur


    Une requête comportant un en-tête `Origin` doit provenir de l'une des
    origines propres à l'application ou de ses origines autorisées, sous peine
    de recevoir une erreur `403 origin_not_allowed`. Les requêtes de serveur à
    serveur n'envoient aucun en-tête `Origin`.


    ## Non traité ici


    Ces routes desservent les pages hébergées, les SDK natifs et de navigateur,
    ainsi que les agents IA. Elles ne font pas partie du contrat serveur, et les
    SDK serveur ne les appellent pas :


    - Étapes de connexion : `POST /authorize/`, `POST /password/`, `/email/*`,
    `/phone/*`, `/password-reset/*`, `/passkeys/*`, `/mfa/*`, `/social/*` et
    `/protection/complete/`.

    - Pages hébergées et rappels : `/sign-in`, `/magic`, `/invite`, `/reset`,
    `/verify/`, `/sso/*`, `/wallet/callback/`, `/logo/` et les fichiers
    d'association d'applications natives sous `/.well-known/`.

    - Accès pour les agents : `/agents/*` et `/grants/`, y compris `GET
    /agents/session/`, la vérification en direct du token d'accès d'un agent IA.
    L'accès des agents ne fait pas partie de cette version du contrat.

    - L'API de gestion de la console pour Authentication, qui requiert des
    sessions de console.


    Les événements d'Authentication ne sont pas encore transmis sous forme de
    webhooks ; ce document ne définit donc aucun webhook.
servers:
  - url: https://{issuer}
    description: 'L''émetteur de votre application : son origine de connexion.'
    variables:
      issuer:
        default: your-app.auth.didit.me
        description: >-
          L'hôte de l'émetteur : `<name>.auth.didit.me` (production),
          `<name>.sandbox.auth.didit.me` (sandbox) ou votre domaine personnalisé
          actif.
security: []
tags:
  - name: Issuer
    description: Clés de découverte et de signature, pour vérifier les tokens.
  - name: Tokens
    description: Les autorisations par code d'autorisation et de renouvellement.
  - name: Sessions
    description: Vérifier et terminer la session associée à un token d'accès.
  - name: Step-ups
    description: Vérification avant une action sensible.
  - name: Monitoring
    description: >-
      Informations d'authentification de l'appareil pour les événements de
      surveillance des transactions.
paths:
  /session/:
    get:
      tags:
        - Sessions
      summary: Obtenir la session
      description: >-
        Vérifie le jeton d'accès par rapport à la session active et le renvoie.
        Plus strict que de vérifier le JWT vous-même : il échoue également
        immédiatement lorsque la session a été révoquée, est devenue inactive ou
        a dépassé sa durée de vie, lorsque la personne a été bloquée ou que son
        e-mail n'est plus vérifié, lorsque la session ne respecte plus votre
        politique MFA (par exemple après que la personne a ajouté une
        application d'authentification ou est devenue administrateur de
        l'organisation), ou lorsque le jeton a été remplacé par un
        rafraîchissement. Utilisez-le avant une action sensible, par exemple un
        versement. Une vérification réussie compte comme une activité,
        réinitialisant ainsi le délai d'inactivité de la session.
      operationId: authentication_get_session
      responses:
        '200':
          description: La session est active.
          headers:
            Cache-Control:
              description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
              schema:
                type: string
                example: no-store
            Pragma:
              description: Toujours `no-cache`.
              schema:
                type: string
                example: no-cache
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Session'
              examples:
                Session:
                  summary: Une session de mot de passe
                  value:
                    sub: 1c9d8b88-1bff-43d1-ad7a-88b2bc0024e9
                    sid: c9abf6cc-2d64-4bf2-b31e-a4d09a070ab1
                    application_id: 7b0a6c2e-3f41-4c9a-8d55-1e2f3a4b5c6d
                    vendor_data: user-42
                    amr:
                      - password
                    mfa_verified: false
                    email: person@example.com
                    email_verified: true
                    phone: null
                    verified_identity: null
                    verified: null
                    expires_at: '2026-11-16T10:41:14.347557Z'
                    post_logout_redirect_uri: ''
                    organizations: []
                VerifiedMember:
                  summary: Un membre d'organisation vérifié
                  value:
                    sub: 1c9d8b88-1bff-43d1-ad7a-88b2bc0024e9
                    sid: c9abf6cc-2d64-4bf2-b31e-a4d09a070ab1
                    application_id: 7b0a6c2e-3f41-4c9a-8d55-1e2f3a4b5c6d
                    vendor_data: user-42
                    amr:
                      - passkey
                    mfa_verified: true
                    email: person@example.com
                    email_verified: true
                    phone: '+34600000000'
                    verified_identity: null
                    verified:
                      level: full_id
                      over_18: true
                      given_name: Alex
                      country: ES
                    expires_at: '2026-11-16T10:41:14.347557Z'
                    post_logout_redirect_uri: https://app.example.com/
                    organizations:
                      - organization_id: 3e9a1f0b-5c2d-4e7f-8a6b-9c0d1e2f3a4b
                        organization__name: Northwind
                        role: admin
                        custom_role: null
        '401':
          $ref: '#/components/responses/InvalidToken'
        '403':
          $ref: '#/components/responses/OriginNotAllowed'
        '404':
          $ref: '#/components/responses/ApplicationNotFound'
        '429':
          $ref: '#/components/responses/RateLimited'
        '503':
          $ref: '#/components/responses/TemporarilyUnavailable'
      security:
        - AccessToken: []
components:
  schemas:
    Session:
      type: object
      description: La session active derrière un token d'accès.
      required:
        - sub
        - sid
        - application_id
        - vendor_data
        - amr
        - mfa_verified
        - email
        - email_verified
        - phone
        - verified_identity
        - verified
        - expires_at
        - post_logout_redirect_uri
        - organizations
      properties:
        sub:
          type: string
          format: uuid
          description: L'ID de l'identité.
          example: 1c9d8b88-1bff-43d1-ad7a-88b2bc0024e9
        sid:
          type: string
          format: uuid
          description: L'ID de session.
          example: c9abf6cc-2d64-4bf2-b31e-a4d09a070ab1
        application_id:
          type: string
          format: uuid
          example: 7b0a6c2e-3f41-4c9a-8d55-1e2f3a4b5c6d
        vendor_data:
          type: string
          description: >-
            La référence de la personne à travers les produits Didit, comme dans
            les tokens.
          example: user-42
        amr:
          $ref: '#/components/schemas/AuthenticationMethods'
        mfa_verified:
          type: boolean
          description: >-
            Indique si la session a validé un second facteur. Vaut toujours
            `true` pour une connexion par passkey.
          example: false
        email:
          type: string
          format: email
          nullable: true
          example: person@example.com
        email_verified:
          type: boolean
          example: true
        phone:
          type: string
          nullable: true
          description: Numéro de téléphone au format E.164, ou `null`.
          example: null
        verified_identity:
          $ref: '#/components/schemas/WalletVerification'
        verified:
          type: object
          nullable: true
          description: >-
            Niveau de vérification et attributs sélectionnés, le même objet que
            celui transmis par les tokens sous `verified`, ou `null` lorsqu'il
            n'y en a aucun. Consultez ce champ, et non `email_verified`, pour
            savoir si la personne a vérifié son identité.
          properties:
            level:
              type: string
              enum:
                - liveness
                - liveness_face_match
                - full_id
              description: >-
                Le niveau le plus élevé validé. Du plus faible au plus fort :
                `liveness`, `liveness_face_match`, `full_id`.
              example: full_id
            over_18:
              type: boolean
              example: true
            over_21:
              type: boolean
              example: true
            given_name:
              type: string
              example: Alex
            family_name:
              type: string
              example: Doe
            birthdate:
              type: string
              description: Date de naissance issue du document, `YYYY-MM-DD`.
              example: '1990-04-12'
            nationality:
              type: string
              description: Code pays ISO 3166-1 alpha-2.
              example: ES
            country:
              type: string
              description: Code ISO 3166-1 alpha-2 du pays du document.
              example: ES
            document_verified:
              type: boolean
              example: true
            liveness:
              type: boolean
              example: true
        expires_at:
          type: string
          format: date-time
          description: >-
            Moment où la session prend fin au plus tard. Le délai d'inactivité
            peut y mettre fin plus tôt.
          example: '2026-11-16T10:41:14.347557Z'
        post_logout_redirect_uri:
          type: string
          description: >-
            Endroit où votre application redirige la personne après la
            déconnexion. Chaîne vide si non défini.
          example: https://app.example.com/
        organizations:
          type: array
          description: >-
            Chaque organisation cliente à laquelle appartient la personne,
            lorsque les organisations sont activées. Vide dans le cas contraire.
          items:
            $ref: '#/components/schemas/SessionOrganization'
    AuthenticationMethods:
      type: array
      description: >-
        Mode de connexion de la session, sous forme d'une valeur unique : par
        exemple `password`, `code` (code par e-mail), `magic` (lien magique),
        `passkey`, `phone`, `sso`, `wallet` (Didit ID Wallet) ou le nom d'une
        méthode de connexion sociale. Vide pour un token d'agent.
      items:
        type: string
      example:
        - password
    WalletVerification:
      type: object
      description: >-
        Ce que le Didit ID Wallet a partagé lors de la connexion. `null` lorsque
        la personne s'est connectée par un autre moyen.
      nullable: true
      required:
        - issuer
        - subject
      properties:
        issuer:
          type: string
          description: L'émetteur du portefeuille.
          example: https://apx.didit.me/auth/idv
        subject:
          type: string
          description: L'identifiant de la personne auprès du portefeuille.
          example: 8b7f5c1e-2d3a-4b5c-9e8f-7a6b5c4d3e2f
        shared_session:
          type: object
          description: >-
            Une vérification que la personne a choisi de partager, que vous
            récupérez à l'aide de votre propre clé API.
          properties:
            share_token:
              type: string
            session_id:
              type: string
            from_application_id:
              type: string
        claims:
          type: object
          description: >-
            Les éléments vérifiés que la personne a accepté de partager, limités
            à ce que votre application a demandé.
          additionalProperties:
            oneOf:
              - type: boolean
              - type: string
          example:
            over_18: true
            given_name: Alex
    SessionOrganization:
      type: object
      required:
        - organization_id
        - organization__name
        - role
        - custom_role
      properties:
        organization_id:
          type: string
          format: uuid
          example: 3e9a1f0b-5c2d-4e7f-8a6b-9c0d1e2f3a4b
        organization__name:
          type: string
          description: Le nom de l'organisation.
          example: Northwind
        role:
          type: string
          enum:
            - admin
            - member
            - billing
          example: admin
        custom_role:
          type: object
          nullable: true
          description: Le rôle personnalisé attribué au membre, ou `null`.
          required:
            - key
            - permissions
          properties:
            key:
              type: string
              example: approver
            permissions:
              type: array
              items:
                type: string
              example:
                - payouts.approve
    Detail:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          example: invalid_token
    OAuthError:
      title: OAuth error
      type: object
      description: Une erreur OAuth (RFC 6749 section 5.2) ou une erreur de service.
      required:
        - error
      properties:
        error:
          type: string
          example: invalid_grant
  responses:
    InvalidToken:
      description: >-
        Le token d'accès est manquant, malformé, expiré, signé par un autre
        émetteur ou une autre clé, est un token d'ID, un token d'agent, ou a été
        remplacé par un rafraîchissement ; ou sa session a été révoquée, a
        expiré pour cause d'inactivité, a dépassé sa durée de vie ou ne respecte
        plus votre politique MFA, ou la personne a été bloquée ou son e-mail
        n'est plus vérifié. Renvoyez la personne vers la connexion.
      headers:
        WWW-Authenticate:
          description: '`Bearer`.'
          schema:
            type: string
            example: Bearer
        Cache-Control:
          description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Toujours `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            InvalidToken:
              summary: Token d'accès rejeté
              value:
                detail: invalid_token
    OriginNotAllowed:
      description: >-
        La requête contenait un `Origin` qui n'est ni celui de l'application ni
        dans ses origines autorisées. Les requêtes serveur n'envoient pas de
        `Origin`.
      headers:
        Cache-Control:
          description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Toujours `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            OriginNotAllowed:
              summary: Origine non autorisée
              value:
                detail: origin_not_allowed
    ApplicationNotFound:
      description: >-
        L'adresse appartient à une application, mais Authentication n'est pas
        actif pour celle-ci ; sur l'adresse `apx.didit.me`, l'identifiant de
        l'application est inconnu. Une adresse n'appartenant à aucune
        application est refusée avant d'atteindre l'endpoint, et cette réponse
        n'est pas en JSON.
      headers:
        Cache-Control:
          description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Toujours `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            ApplicationNotFound:
              summary: Application inconnue
              value:
                detail: No Configuration matches the given query.
    RateLimited:
      description: >-
        Trop de requêtes issues de cette adresse IP pour cet endpoint, ou, sur
        un `POST` ou `DELETE`, un compartiment de protection contre les robots
        est vide. Rien n'a été exécuté : attendez `Retry-After` secondes, puis
        réessayez.
      headers:
        Retry-After:
          description: Secondes à attendre avant de réessayer.
          schema:
            type: integer
            example: 60
        Cache-Control:
          description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Toujours `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            RateLimited:
              summary: Limite du endpoint
              value:
                detail: >-
                  Too many requests from this IP address. Please wait before
                  trying again. Expected available in 60 seconds.
            BotProtection:
              summary: Limite de protection contre les bots (POST et DELETE)
              value:
                detail: rate_limited Expected available in 2 seconds.
    TemporarilyUnavailable:
      description: >-
        Un service dont dépend la requête est temporairement indisponible.
        Réessayez en augmentant progressivement l'intervalle entre les
        tentatives.
      headers:
        Cache-Control:
          description: 'Toujours `no-store` : ne jamais mettre cette réponse en cache.'
          schema:
            type: string
            example: no-store
        Pragma:
          description: Toujours `no-cache`.
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OAuthError'
          examples:
            TemporarilyUnavailable:
              summary: Réessayer plus tard
              value:
                error: temporarily_unavailable
  securitySchemes:
    AccessToken:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        Le token d'accès de la personne issu de `POST /token/` : un JWT ES256
        avec l'en-tête `typ: at+jwt`, valide pendant au plus 5 minutes. Il ne
        s'agit pas de votre clé API Didit.

````

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