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

# Actualiser une connexion bancaire API : synchronisation immédiate

> Didit synchronise une connexion bancaire maintenant : 202 avec le sync_id, ou 200 avec le résultat si vous patientez 25 secondes.

L'endpoint Refresh a Bank Connection de Didit demande une synchronisation immédiate et répond `202` avec le `sync_id`.
Envoyez `"wait": true` pour patienter jusqu'à 25 secondes et obtenir la synchronisation terminée en un seul appel, sans frais supplémentaires.
La banque limite l'accès non supervisé : l'appel peut donc répondre `429 refresh_limit_reached` avec `Retry-After`.
Voir [Actualiser les données bancaires à la demande](https://docs.didit.me/fr/use-cases/refresh-bank-data-on-demand.md).


## OpenAPI

````yaml fr/openapi-25.json POST /v3/bank/connections/{id}/refresh/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags:
  - name: Bank Data
    description: >-
      Bank Link, connexions, comptes, soldes, transactions, établissements et
      couverture. Les données bancaires sont disponibles pour les applications
      en sandbox. Les appels d'une application en production renvoient `404`
      tant que l'accès en production n'est pas annoncé. Rien n'est facturé en
      sandbox. Un appel effectué avec une clé API doit utiliser une clé qui
      porte l'autorisation Données bancaires (`bank-data`) : lecture pour les
      lectures, écriture pour les opérations qui modifient quelque chose. La
      vérification de compte fait exception : elle nécessite un accès en
      écriture aux sessions, ou un accès complet, et non l'autorisation Données
      bancaires. Les données bancaires ne font pas partie de l'accès complet :
      une clé à accès complet est refusée, et l'appel renvoie `403
      bank_data_access_denied` tant que vous n'avez pas créé une clé portant
      cette autorisation. Une requête qui ne porte aucune clé API est également
      refusée pour les données bancaires brutes (comptes, soldes, transactions
      et flux des modifications).


      Chaque refus sous `/v3/bank/`, sauf celui de la vérification de compte, a
      le même corps JSON (`code`, `message`, `request_id`, `field`,
      `next_action`, `retry_after`). Un chemin qui n'est pas une opération, un
      identifiant qui n'est pas un UUID ou une sous-ressource inconnue renvoie
      `404 not_found` quelle que soit la méthode, et toute erreur inattendue
      renvoie `500 internal_error` avec un `request_id`. Lorsque les données
      bancaires ne sont pas disponibles, chaque opération renvoie le `404`
      standard de la plateforme, exactement comme une route inconnue.
paths:
  /v3/bank/connections/{id}/refresh/:
    post:
      tags:
        - Bank Data
      summary: Actualiser une connexion bancaire
      description: >-
        Synchronisations immédiates : interroge la banque pour obtenir de
        nouvelles données à tout moment. Répond `202` avec le `sync_id` ; si une
        synchronisation est déjà en cours, vous recevez ce même `sync_id`, et
        non un second travail. Avec `"wait": true` dans le corps, ou l'en-tête
        `Prefer: wait=<seconds>` (jusqu'à 25), l'appel patiente jusqu'à 25
        secondes et répond `200` avec la synchronisation terminée (`outcome`,
        les compteurs par compte et `balances_changed`), de sorte qu'une seule
        requête renvoie des données à jour. Si la banque n'a pas répondu dans ce
        délai, l'appel répond `202` : lisez la synchronisation avec
        `get_sync_run` à l'aide du `sync_id`, ou abonnez-vous à
        `bank.sync.completed`. `bank.data.updated` n'est envoyé que si la
        synchronisation enregistre des modifications.


        Les synchronisations immédiates sont incluses dans le prix mensuel de la
        connexion, comme les synchronisations automatiques : aucun frais
        supplémentaire n'est facturé. La seule limite est celle de la banque.
        Les banques limitent les lectures effectuées sans la présence de la
        personne, par exemple à quatre par jour (la banque de test Didit en
        sandbox fait de même). Les synchronisations automatiques du jour
        (`sync.frequency_per_day`) sont réservées en premier, et le reste est à
        votre disposition : `sync.budgets` indique ce qui reste et
        `sync.live_syncs_left_today` le nombre de synchronisations immédiates
        restantes aujourd'hui. La planification automatique n'utilise jamais les
        deux dernières lectures de la journée, si bien que deux synchronisations
        immédiates restent toujours disponibles. Lorsque le budget est épuisé,
        l'appel répond `429 refresh_limit_reached` avec `Retry-After` (le nombre
        de secondes avant la réinitialisation du budget, de 1 à 86400) et un
        objet `sync` contenant `live_syncs_left_today` et `budgets`. Cette
        limite est un plafond fixé par la banque, et non une garantie d'un
        nombre de synchronisations.


        Lorsqu'une synchronisation enregistre des modifications,
        `bank.data.updated` vous en informe ; lisez alors le flux des
        modifications.


        Nécessite une clé API disposant de l'autorisation Bank data
        (`bank-data`) : en écriture pour cette opération, qui modifie des
        données. Une clé à accès complet ne l'inclut pas : accordez-la
        explicitement lors de la création de la clé, sans quoi l'appel répond
        `403 bank_data_access_denied`.


        Actualiser une connexion supprimée répond `409 connection_not_active`.
      operationId: refreshBankConnection
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: L'identifiant de la connexion.
        - $ref: '#/components/parameters/IdempotencyKey'
        - name: Prefer
          in: header
          required: false
          schema:
            type: string
            example: wait=25
          description: >-
            `wait=<seconds>` maintient l'appel jusqu'à ce nombre de secondes, au
            maximum 25, comme `wait: true` dans le corps de la requête.
      requestBody:
        required: false
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankRefreshRequest'
            examples:
              Wait for the result:
                summary: Attendre le résultat.
                value:
                  wait: true
      responses:
        '200':
          description: La synchronisation s'est terminée dans les 25 secondes.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankSyncCompleted'
              examples:
                Finished:
                  summary: Une synchronisation de production terminée
                  value:
                    id: d4a9e7b2-1c58-4f03-96ab-5e2d8c7f0b14
                    connection_id: 5e1d2a70-6b3c-4f8e-a1d9-0c7b2e4f8a36
                    trigger: requested
                    status: succeeded
                    started_at: '2026-11-21T12:30:02Z'
                    finished_at: '2026-11-21T12:30:09Z'
                    results:
                      - account_id: a71f0c2e-4d85-4b1a-9e63-2f8c0d5b7a14
                        resource: transactions
                        outcome: succeeded
                        added: 3
                        modified: 0
                        removed: 1
                        error: null
                    outcome: succeeded
                    balances_changed: true
                    error: null
        '202':
          description: >-
            Actualisation acceptée : en file d'attente ou déjà en cours. Avec
            `wait`, la banque n'a pas répondu dans les 25 secondes : consultez
            la synchronisation avec le `sync_id`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshAccepted'
              examples:
                Queued:
                  summary: Une synchronisation a été mise en file d'attente
                  value:
                    sync_id: d4a9e7b2-1c58-4f03-96ab-5e2d8c7f0b14
                    status: queued
                    next_refresh_at: null
        '400':
          description: >-
            Le corps de la requête n'est pas valide, par exemple `wait` n'est
            pas un booléen. `field` l'indique.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Invalid request:
                  summary: Requête invalide
                  value:
                    code: invalid_request
                    message: The request is not valid.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: wait
                    next_action: null
                    retry_after: null
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/BankDataAccessDenied'
        '404':
          description: >-
            La ressource n'existe pas dans cette application et cet
            environnement.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not found:
                  summary: Introuvable
                  value:
                    code: not_found
                    message: The resource does not exist.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: null
                    retry_after: null
        '409':
          description: >-
            La connexion ne peut pas être actualisée : `connection_not_active`
            (révoquée, suspendue, en échec ou supprimée) ou `consent_expired`
            (la renouveler d'abord).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not active:
                  summary: Inactive
                  value:
                    code: connection_not_active
                    message: This connection is not active.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: create_link
                    retry_after: null
                Consent expired:
                  summary: Consentement expiré
                  value:
                    code: consent_expired
                    message: The consent ended. Renew the connection to sync again.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: renew_connection
                    retry_after: null
        '429':
          description: >-
            Le budget de la banque pour les récupérations effectuées sans la
            présence de la personne est épuisé.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshLimitError'
              examples:
                Refresh limit reached:
                  summary: Limite d'actualisations atteinte
                  value:
                    code: refresh_limit_reached
                    message: >-
                      The bank's limit on fetches without the person present is
                      used up for today.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: retry_later
                    retry_after: 3600
                    sync:
                      live_syncs_left_today: 0
                      budgets:
                        - scope: connection
                          resource: all
                          limit: 4
                          remaining: 0
                          resets_at: '2026-11-22T00:00:00Z'
          headers:
            Retry-After:
              description: Secondes à attendre avant d'effectuer une nouvelle requête.
              schema:
                type: integer
        '500':
          $ref: '#/components/responses/BankDataInternalError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/bank/connections/5e1d2a70-3b94-4c1f-8a6e-d2f07b9c1e35/refresh/'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.refresh_connection(
                "11111111-2222-3333-4444-555555555555",
                wait=True,
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: >-
            import Didit from "@didit-protocol/sdk-node";


            // Reads DIDIT_API_KEY.

            const didit = new Didit();


            const result = await
            didit.bank.refreshConnection("11111111-2222-3333-4444-555555555555",
            {
              wait: true,
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.RefreshConnection(ctx, \"11111111-2222-3333-4444-555555555555\", didit.BankRefreshConnectionParams{\n\tBody: didit.BankRefreshRequest{\n\t\tWait: didit.Bool(true),\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;

            import me.didit.types.BankRefreshConnectionParams;

            import me.didit.types.BankRefreshRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().refreshConnection("11111111-2222-3333-4444-555555555555",
            BankRefreshConnectionParams.builder()
                    .wait_(true)
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $result =
            $didit->bank->refreshConnection('11111111-2222-3333-4444-555555555555',
            [
                'wait' => true,
            ]);

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

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.bank.refresh_connection(
              "11111111-2222-3333-4444-555555555555",
              wait: true
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await
            client.Bank.RefreshConnectionAsync("11111111-2222-3333-4444-555555555555",
            new BankRefreshRequest

            {
                Wait = true,
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  parameters:
    IdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >-
        Clé facultative de sécurisation des nouvelles tentatives, que vous
        choisissez pour une opération, d'au plus 255 caractères (un UUID
        convient). Une requête répétée avec la même clé, le même endpoint, les
        mêmes paramètres de requête et le même corps reçoit la première réponse,
        avec le même statut et le même corps, et n'est ni exécutée ni facturée
        une seconde fois. La même clé avec un autre endpoint, d'autres
        paramètres de requête ou un autre corps renvoie `409`
        `idempotency_key_reused`. Tant que la première requête est encore en
        cours, elle renvoie `409` `idempotency_key_in_progress` avec
        `Retry-After`. Une requête échouée (tout `4xx` ou `5xx`) n'est pas
        enregistrée, vous pouvez donc la renvoyer avec la même clé. Les clés
        sont propres à votre application, que vous appeliez avec une clé API ou
        un jeton d'accès. Voir [Nouvelles tentatives et
        idempotence](/fr/integration/api-errors#nouvelles-tentatives-et-idempotence).
      schema:
        type: string
        minLength: 1
        maxLength: 255
  schemas:
    BankRefreshRequest:
      type: object
      description: Corps facultatif d'une actualisation.
      properties:
        wait:
          type: boolean
          default: false
          description: "`true` maintient l'appel jusqu'à 25 secondes et répond `200` avec la synchronisation terminée, de sorte qu'une seule requête renvoie des données à jour. Si la banque n'a pas répondu dans ce délai, l'appel répond `202` :\_lisez la synchronisation avec `get_sync_run` en utilisant le `sync_id`, ou abonnez-vous à `bank.sync.completed`. `bank.data.updated` n'est envoyé que si la synchronisation enregistre des modifications. L'en-tête `Prefer: wait=<seconds>` (jusqu'à 25) produit le même effet."
    BankSyncCompleted:
      allOf:
        - $ref: '#/components/schemas/BankSyncRun'
        - type: object
          properties:
            outcome:
              type: string
              enum:
                - succeeded
                - partial
                - failed
              description: Résultat de la synchronisation.
            balances_changed:
              type: boolean
              description: Si un solde a changé.
          required:
            - outcome
            - balances_changed
      description: >-
        Une synchronisation terminée renvoyée par une actualisation avec `wait`
        : l'exécution de synchronisation avec son `outcome`, les décomptes par
        compte dans `results` et `balances_changed`.
    BankRefreshAccepted:
      type: object
      description: >-
        Une actualisation a été acceptée. Un second appel pendant qu'une
        synchronisation est en cours renvoie le même `sync_id`.
      properties:
        sync_id:
          type: string
          description: La synchronisation mise en file d'attente, ou celle déjà en cours.
          format: uuid
        status:
          type: string
          enum:
            - queued
            - running
        next_refresh_at:
          type: string
          description: >-
            Le moment le plus tôt auquel une nouvelle actualisation peut être
            demandée. `null` sauf si un budget est épuisé.
          format: date-time
          nullable: true
      required:
        - sync_id
        - status
        - next_refresh_at
    BankDataError:
      type: object
      description: >-
        Corps d'erreur de toutes les opérations sur les données bancaires.
        Chaque champ est toujours présent.
      properties:
        code:
          type: string
          enum:
            - ongoing_access_not_available
            - segment_not_available
            - window_not_available
            - history_window_ambiguous
            - redirect_url_not_registered
            - link_origin_not_allowed
            - bank_data_access_denied
            - connection_not_active
            - consent_expired
            - renewal_not_needed
            - renewal_window_expired
            - access_removed
            - refresh_limit_reached
            - cursor_expired
            - page_expired
            - invalid_cursor
            - page_token_mismatch
            - contract_rate_missing
            - insufficient_credits
            - invalid_request
            - not_found
            - internal_error
          description: >-
            Code d'erreur lisible par machine. Fondez votre logique sur ce code,
            jamais sur `message`.
        message:
          type: string
          description: "Explication en langage clair pour un développeur. Le libellé peut changer\_; ne l'analysez pas."
        request_id:
          type: string
          description: >-
            Identifiant de cette requête. Indiquez-le lorsque vous contactez le
            support.
        field:
          type: string
          description: >-
            Le champ de la requête à corriger, lorsque l'erreur concerne un seul
            champ. Sinon `null`.
          nullable: true
        next_action:
          type: string
          enum:
            - retry_later
            - renew_connection
            - create_link
            - restart_from_cursor
            - restart_read
            - top_up_balance
            - enable_bank_data_access
            - contact_support
            - null
          description: >-
            La prochaine étape à suivre, pour qu'un client puisse agir sans
            deviner. `null` lorsqu'il n'existe pas d'étape suivante standard.
          nullable: true
        retry_after:
          type: integer
          description: >-
            Secondes à attendre avant de réessayer. Défini pour les erreurs de
            limite de débit et les erreurs temporaires, sinon `null`.
          nullable: true
      required:
        - code
        - message
        - request_id
        - field
        - next_action
        - retry_after
      example:
        code: ongoing_access_not_available
        message: >-
          This bank cannot keep access open. Use access one_time or choose
          another bank.
        request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
        field: institution_id
        next_action: create_link
        retry_after: null
    BankRefreshLimitError:
      allOf:
        - $ref: '#/components/schemas/BankDataError'
        - type: object
          properties:
            sync:
              type: object
              description: Les limites de synchronisation actuelles de la connexion.
              properties:
                live_syncs_left_today:
                  type: integer
                  nullable: true
                  minimum: 0
                budgets:
                  type: array
                  items:
                    $ref: '#/components/schemas/BankSyncBudget'
              required:
                - live_syncs_left_today
                - budgets
          required:
            - sync
      description: >-
        Erreur de limite d'actualisation avec les limites `sync` de la
        connexion. `Retry-After` indique le nombre de secondes avant la
        réinitialisation du quota, entre 1 et 86400.
    BankSyncRun:
      type: object
      description: >-
        Une synchronisation d'une connexion. Seules les synchronisations
        initiales, planifiées et demandées sont listées.
      properties:
        id:
          type: string
          format: uuid
        connection_id:
          type: string
          format: uuid
        trigger:
          type: string
          enum:
            - initial
            - scheduled
            - requested
        status:
          type: string
          enum:
            - queued
            - running
            - succeeded
            - partial
            - failed
        started_at:
          type: string
          format: date-time
          nullable: true
        finished_at:
          type: string
          format: date-time
          nullable: true
        results:
          type: array
          items:
            $ref: '#/components/schemas/BankSyncRunResult'
          description: Ce que l'exécution a fait, par compte et par ressource.
        error:
          type: object
          nullable: true
          description: >-
            Pourquoi l'exécution a échoué dans son ensemble. `null` si ce n'est
            pas le cas. Les erreurs liées aux comptes et aux ressources pris
            individuellement figurent dans `results`.
          properties:
            code:
              type: string
            message:
              type: string
            at:
              type: string
              format: date-time
          required:
            - code
            - message
            - at
      required:
        - id
        - connection_id
        - trigger
        - status
        - started_at
        - finished_at
        - results
        - error
    BankSyncBudget:
      type: object
      description: >-
        Une tranche de la limite de la banque sur les récupérations effectuées
        sans la présence de la personne.
      properties:
        scope:
          type: string
          enum:
            - connection
            - account
          description: Ce à quoi la banque impute le budget.
        resource:
          type: string
          enum:
            - all
            - accounts
            - balances
            - transactions
        account_id:
          type: string
          description: Le compte, lorsque `scope` vaut `account`.
          format: uuid
          nullable: true
        limit:
          type: integer
          description: >-
            Nombre de fois par jour où Didit peut interroger la banque en
            l'absence de la personne, selon la définition de la banque. Il
            s'agit d'un plafond fixé par la banque, et non d'une garantie.
        remaining:
          type: integer
          description: >-
            Lectures restantes pour vos actualisations dans la fenêtre en cours.
            Les lectures réservées aux synchronisations automatiques sont déjà
            déduites, et une synchronisation automatique ne prend jamais les
            deux dernières lectures de la journée, afin que deux actualisations
            à la demande restent toujours disponibles.
        resets_at:
          type: string
          description: Quand la fenêtre se réinitialise.
          format: date-time
      required:
        - scope
        - resource
        - limit
        - remaining
        - resets_at
    BankSyncRunResult:
      type: object
      properties:
        account_id:
          type: string
          description: '`null` pour un résultat à l''échelle de la connexion.'
          format: uuid
          nullable: true
        resource:
          type: string
          enum:
            - accounts
            - balances
            - transactions
        outcome:
          type: string
          enum:
            - succeeded
            - failed
            - skipped
        added:
          type: integer
        modified:
          type: integer
        removed:
          type: integer
        error:
          allOf:
            - $ref: '#/components/schemas/BankSyncError'
          nullable: true
          description: Obligatoire lorsque `outcome` vaut `failed`.
      required:
        - account_id
        - resource
        - outcome
        - added
        - modified
        - removed
        - error
    BankSyncError:
      type: object
      description: Pourquoi une synchronisation a échoué.
      properties:
        code:
          type: string
          description: Code d'erreur Didit.
        message:
          type: string
          description: Explication en langage clair.
        at:
          type: string
          description: Quand l'événement s'est produit. `null` sur un résultat par compte.
          format: date-time
          nullable: true
      required:
        - code
        - message
        - at
  responses:
    Unauthorized:
      description: Non autorisé
      content:
        application/json:
          examples:
            Invalid API Key:
              summary: Clé API invalide
              value:
                detail: Invalid API Key.
    BankDataAccessDenied:
      description: >-
        La clé API ne dispose pas de l'autorisation Bank data (`bank-data`) ou,
        pour les données bancaires brutes d'une application en production, le
        paramètre d'application « Bank data in the API » est désactivé. Les
        données bancaires ne font pas partie de l'accès complet : une clé à
        accès complet, une clé limitée à d'autres ressources et une requête
        authentifiée sans clé API (identifiants client, pour les données brutes)
        sont toutes refusées avec ce corps de réponse. Créez donc une clé et
        accordez-lui explicitement l'autorisation. Ce refus intervient avant
        toute recherche : il ne dit donc rien de l'existence d'un objet.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            Bank data not allowed:
              summary: Données bancaires non autorisées
              value:
                code: bank_data_access_denied
                message: >-
                  Bank data calls need an API key that carries the Bank data
                  permission.
                request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                field: null
                next_action: enable_bank_data_access
                retry_after: null
    BankDataInternalError:
      description: >-
        Un problème s’est produit côté Didit. Toute erreur inattendue sous
        `/v3/bank/` répond dans le format d’erreur Bank, jamais par une page
        HTML : indiquez `request_id` au support.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            Internal error:
              summary: Une erreur inattendue
              value:
                code: internal_error
                message: >-
                  Something went wrong on our side. Quote the request_id to
                  support.
                request_id: 3f6a1c8e92b54d07a1e38c4b7f0d2e59
                field: null
                next_action: contact_support
                retry_after: null
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: "La clé API de votre application, disponible dans Developers -> API keys de la Business Console. La clé principale a un accès complet. Une clé nommée peut être limitée :\_aucun accès, lecture ou écriture par ressource, restreinte à certains workflows ou à certaines sessions approuvées, à une liste d'adresses IP et à une date d'expiration. 401 signifie que la clé est incorrecte, révoquée ou expirée\_; 403 signifie qu'aucune clé n'a été envoyée, que la clé n'a pas accès à cette ressource ou à cette action, ou que la requête provient d'une adresse hors de sa liste d'adresses IP\_; 404 sur une route de session signifie que la session se trouve hors des workflows ou des statuts de la clé. Une clé sans accès aux médias reçoit les URL des images, vidéos et PDF à null, et une clé sans accès en écriture aux sessions reçoit les liens et tokens de session à null. Voir https://docs.didit.me/console/api-keys."

````

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