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

# Aggiorna connessione bancaria API: sincronizza ora

> Didit aggiorna subito la connessione bancaria: 202 con il sync_id, oppure 200 con la sincronizzazione completata se attendi fino a 25 secondi.

L'endpoint Refresh a Bank Connection di Didit richiede una sincronizzazione immediata e risponde con `202` e il `sync_id`.
Invia `"wait": true` per attendere fino a 25 secondi e ottenere la sincronizzazione completata in una sola chiamata, senza costi aggiuntivi.
La banca limita l'accesso non presidiato, quindi la chiamata può rispondere con `429 refresh_limit_reached` e `Retry-After`.
Vedi [Aggiornare i dati bancari su richiesta](https://docs.didit.me/it/use-cases/refresh-bank-data-on-demand.md).


## OpenAPI

````yaml it/openapi-25.json POST /v3/bank/connections/{id}/refresh/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API di verifica dell'identità. Autenticati con l'header x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags:
  - name: Bank Data
    description: >-
      Bank Link, connessioni, conti, saldi, transazioni, istituti e copertura. I
      dati bancari sono disponibili per le applicazioni sandbox. Le chiamate di
      un'applicazione in produzione restituiscono `404` finché l'accesso di
      produzione non viene annunciato. Nel sandbox non viene addebitato nulla.
      Una chiamata effettuata con una chiave API richiede una chiave che abbia
      l'autorizzazione dati bancari (`bank-data`): lettura per le letture,
      scrittura per le operazioni che modificano qualcosa. Il controllo del
      conto fa eccezione: richiede accesso in scrittura alle sessioni, oppure
      accesso completo, e non l'autorizzazione dati bancari. I dati bancari non
      fanno parte dell'accesso completo: una chiave con accesso completo viene
      rifiutata e la chiamata risponde `403 bank_data_access_denied` finché non
      crei una chiave che abbia l'autorizzazione. I dati bancari grezzi (conti,
      saldi, transazioni e flusso delle modifiche) rifiutano anche una richiesta
      che non contiene una chiave API.


      Ogni rifiuto sotto `/v3/bank/`, eccetto quello del controllo del conto, ha
      lo stesso corpo JSON (`code`, `message`, `request_id`, `field`,
      `next_action`, `retry_after`). Un percorso che non è un'operazione, un ID
      che non è un UUID o una sotto-risorsa sconosciuta risponde `404 not_found`
      per ogni metodo, e qualsiasi errore imprevisto risponde `500
      internal_error` con un `request_id`. Dove i dati bancari non sono
      disponibili, ogni operazione risponde con il `404` standard della
      piattaforma, esattamente come fa un percorso sconosciuto.
paths:
  /v3/bank/connections/{id}/refresh/:
    post:
      tags:
        - Bank Data
      summary: Aggiorna una connessione bancaria
      description: >-
        Sincronizza subito: legge dalla banca nuovi dati in qualsiasi momento.
        Risponde `202` con il `sync_id`; se una sincronizzazione è già in corso
        ottieni lo stesso `sync_id`, non un secondo processo. Con `"wait": true`
        nel corpo, oppure con l'intestazione `Prefer: wait=<seconds>` (fino a
        25), la chiamata attende per un massimo di 25 secondi e risponde `200`
        con la sincronizzazione completata (`outcome`, i conteggi per conto e
        `balances_changed`), così una sola richiesta restituisce dati
        aggiornati. Se in quel tempo la banca non ha risposto, risponde `202`:
        leggi la sincronizzazione con `get_sync_run` usando il `sync_id`, oppure
        iscriviti a `bank.sync.completed`. `bank.data.updated` arriva solo se la
        sincronizzazione salva modifiche.


        Le sincronizzazioni live sono incluse nel prezzo mensile della
        connessione, come quelle automatiche: non viene addebitato nulla in più.
        L'unico limite è quello della banca. Le banche limitano le letture fatte
        senza la presenza della persona, ad esempio a quattro al giorno (la
        Didit Test Bank in sandbox fa lo stesso). Le sincronizzazioni
        automatiche del giorno (`sync.frequency_per_day`) vengono riservate per
        prime e le restanti sono tue, quindi `sync.budgets` mostra quanto resta
        e `sync.live_syncs_left_today` quante sincronizzazioni live restano
        oggi. La pianificazione automatica non usa mai le ultime due letture
        della giornata, quindi restano sempre due sincronizzazioni live. Quando
        il budget è esaurito, la chiamata risponde `429 refresh_limit_reached`
        con `Retry-After` (i secondi fino al ripristino del budget, da 1 a
        86400) e un oggetto `sync` con `live_syncs_left_today` e `budgets`. Il
        limite è un tetto impostato dalla banca, non una promessa di un certo
        numero di sincronizzazioni.


        Quando una sincronizzazione salva modifiche, `bank.data.updated` te lo
        segnala; poi leggi il flusso delle modifiche.


        Serve una chiave API con l'autorizzazione Bank data (`bank-data`):
        scrittura per questa operazione, che modifica qualcosa. Una chiave con
        accesso completo non la include: concedila esplicitamente quando crei la
        chiave, altrimenti la chiamata risponde `403 bank_data_access_denied`.


        Aggiornare una connessione eliminata risponde `409
        connection_not_active`.
      operationId: refreshBankConnection
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: L'id della connessione.
        - $ref: '#/components/parameters/IdempotencyKey'
        - name: Prefer
          in: header
          required: false
          schema:
            type: string
            example: wait=25
          description: >-
            `wait=<seconds>` mantiene in attesa la chiamata per il numero di
            secondi indicato, al massimo 25, come `wait: true` nel corpo della
            richiesta.
      requestBody:
        required: false
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankRefreshRequest'
            examples:
              Wait for the result:
                summary: Attendi il risultato
                value:
                  wait: true
      responses:
        '200':
          description: La sincronizzazione è terminata entro 25 secondi.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankSyncCompleted'
              examples:
                Finished:
                  summary: Una sincronizzazione live terminata
                  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: >-
            Aggiornamento accettato: in coda o già in esecuzione. Con `wait`, la
            banca non ha risposto entro 25 secondi: recupera la sincronizzazione
            con il `sync_id`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshAccepted'
              examples:
                Queued:
                  summary: È stata accodata una sincronizzazione
                  value:
                    sync_id: d4a9e7b2-1c58-4f03-96ab-5e2d8c7f0b14
                    status: queued
                    next_refresh_at: null
        '400':
          description: >-
            Il corpo non è valido, per esempio `wait` non è un booleano. `field`
            lo indica.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Invalid request:
                  summary: Richiesta non valida
                  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 risorsa non esiste in questa applicazione e in questo ambiente.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not found:
                  summary: Non trovato
                  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 connessione non può essere aggiornata: `connection_not_active`
            (revocata, sospesa, fallita o eliminata) oppure `consent_expired`
            (rinnovala prima).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Not active:
                  summary: Non attiva
                  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: Consenso scaduto
                  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: >-
            Il budget della banca per le letture senza la persona presente è
            esaurito.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankRefreshLimitError'
              examples:
                Refresh limit reached:
                  summary: Limite di aggiornamenti raggiunto
                  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: Secondi da attendere prima di riprovare.
              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: >-
        Chiave facoltativa per la sicurezza dei nuovi tentativi, da scegliere
        per una singola operazione, fino a 255 caratteri (va bene un UUID). Una
        richiesta ripetuta con la stessa chiave, lo stesso endpoint, la stessa
        query e lo stesso body riceve la prima risposta, con lo stesso status e
        lo stesso body, e non viene eseguita né fatturata una seconda volta. Con
        la stessa chiave ma un altro endpoint, query o body viene restituito
        `409` `idempotency_key_reused`; mentre la prima richiesta è ancora in
        esecuzione, viene restituito `409` `idempotency_key_in_progress` con
        `Retry-After`. Una richiesta non riuscita (qualsiasi `4xx` o `5xx`) non
        viene memorizzata, quindi puoi inviarla di nuovo con la stessa chiave.
        Le chiavi appartengono alla tua applicazione, sia che tu chiami con una
        chiave API sia con un token di accesso. Vedi [Nuovi tentativi e
        idempotenza](/it/integration/api-errors#nuovi-tentativi-e-idempotenza).
      schema:
        type: string
        minLength: 1
        maxLength: 255
  schemas:
    BankRefreshRequest:
      type: object
      description: Corpo facoltativo di un aggiornamento.
      properties:
        wait:
          type: boolean
          default: false
          description: >-
            `true` tiene in attesa la chiamata per un massimo di 25 secondi e
            risponde `200` con la sincronizzazione completata, così una sola
            richiesta restituisce dati aggiornati. Se la banca non ha risposto
            entro quel tempo, la chiamata risponde `202`: leggi la
            sincronizzazione con `get_sync_run` usando il `sync_id`, oppure
            iscriviti a `bank.sync.completed`. `bank.data.updated` arriva solo
            se la sincronizzazione memorizza modifiche. L'intestazione `Prefer:
            wait=<seconds>` (fino a 25) fa lo stesso.
    BankSyncCompleted:
      allOf:
        - $ref: '#/components/schemas/BankSyncRun'
        - type: object
          properties:
            outcome:
              type: string
              enum:
                - succeeded
                - partial
                - failed
              description: Come è terminata la sincronizzazione.
            balances_changed:
              type: boolean
              description: Se un saldo è cambiato.
          required:
            - outcome
            - balances_changed
      description: >-
        Una sincronizzazione terminata restituita da un aggiornamento con
        `wait`: l'esecuzione della sincronizzazione con il suo `outcome`, i
        conteggi per conto in `results` e `balances_changed`.
    BankRefreshAccepted:
      type: object
      description: >-
        Un aggiornamento è stato accettato. Una seconda chiamata mentre una
        sincronizzazione è in corso restituisce lo stesso `sync_id`.
      properties:
        sync_id:
          type: string
          description: La sincronizzazione accodata, oppure quella già in esecuzione.
          format: uuid
        status:
          type: string
          enum:
            - queued
            - running
        next_refresh_at:
          type: string
          description: >-
            Il primo momento in cui è possibile richiedere un nuovo
            aggiornamento. `null` a meno che un budget non sia esaurito.
          format: date-time
          nullable: true
      required:
        - sync_id
        - status
        - next_refresh_at
    BankDataError:
      type: object
      description: >-
        Corpo dell'errore di ogni operazione Bank data. Ogni campo è sempre
        presente.
      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: >-
            Codice di errore leggibile dalla macchina. Usalo per la diramazione
            della logica, mai `message`.
        message:
          type: string
          description: >-
            Spiegazione in linguaggio semplice per uno sviluppatore. Il testo
            può cambiare; non analizzarlo.
        request_id:
          type: string
          description: >-
            Identificativo di questa richiesta. Citalo quando contatti il
            supporto.
        field:
          type: string
          description: >-
            Il campo della richiesta da correggere, quando l'errore riguarda un
            solo campo. Altrimenti `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: >-
            Cosa fare dopo, così un client può agire senza fare supposizioni.
            `null` quando non esiste un passaggio successivo standard.
          nullable: true
        retry_after:
          type: integer
          description: >-
            Secondi da attendere prima di riprovare. Impostato in caso di limite
            di frequenza ed errori temporanei, altrimenti `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: I limiti di sincronizzazione attuali della connessione.
              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: >-
        L'errore di limite di aggiornamento con i limiti `sync` della
        connessione. `Retry-After` indica i secondi che mancano al ripristino
        del budget, tra 1 e 86400.
    BankSyncRun:
      type: object
      description: >-
        Una sincronizzazione di una connessione. Sono elencate solo le
        sincronizzazioni iniziali, programmate e richieste.
      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: Cosa ha fatto l'esecuzione, per account e per risorsa.
        error:
          type: object
          nullable: true
          description: >-
            Perché l'esecuzione non è riuscita nel suo complesso. `null` quando
            non è così. Gli errori dei singoli conti e delle singole risorse si
            trovano in `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: Una quota del limite della banca sui recuperi senza la persona presente.
      properties:
        scope:
          type: string
          enum:
            - connection
            - account
          description: Rispetto a cosa la banca conteggia il budget.
        resource:
          type: string
          enum:
            - all
            - accounts
            - balances
            - transactions
        account_id:
          type: string
          description: Il conto, quando `scope` è `account`.
          format: uuid
          nullable: true
        limit:
          type: integer
          description: >-
            Quante volte al giorno Didit può recuperare dati dalla banca senza
            la presenza della persona, secondo la definizione della banca. È un
            tetto imposto dalla banca, non una garanzia.
        remaining:
          type: integer
          description: >-
            Letture ancora disponibili per i tuoi aggiornamenti nella finestra
            corrente. Le letture riservate alle sincronizzazioni automatiche
            sono già detratte, e una sincronizzazione automatica non usa mai le
            ultime due letture della giornata, quindi restano sempre disponibili
            due aggiornamenti su richiesta.
        resets_at:
          type: string
          description: Quando la finestra si reimposta.
          format: date-time
      required:
        - scope
        - resource
        - limit
        - remaining
        - resets_at
    BankSyncRunResult:
      type: object
      properties:
        account_id:
          type: string
          description: '`null` per un risultato relativo a tutta la connessione.'
          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: Obbligatorio quando `outcome` è `failed`.
      required:
        - account_id
        - resource
        - outcome
        - added
        - modified
        - removed
        - error
    BankSyncError:
      type: object
      description: Perché una sincronizzazione non è riuscita.
      properties:
        code:
          type: string
          description: Codice di errore Didit.
        message:
          type: string
          description: Spiegazione in linguaggio semplice.
        at:
          type: string
          description: Quando è avvenuto. `null` in un risultato per conto.
          format: date-time
          nullable: true
      required:
        - code
        - message
        - at
  responses:
    Unauthorized:
      description: Non autorizzato
      content:
        application/json:
          examples:
            Invalid API Key:
              summary: Chiave API non valida
              value:
                detail: Invalid API Key.
    BankDataAccessDenied:
      description: >-
        La chiave API non ha l'autorizzazione Bank data (`bank-data`) oppure,
        per i dati bancari grezzi in un'applicazione live, l'impostazione
        dell'applicazione "Bank data in the API" è disattivata. I dati bancari
        non fanno parte dell'accesso completo: una chiave con accesso completo,
        una chiave limitata ad altre risorse e una richiesta autenticata senza
        chiave API (client credentials, sui dati grezzi) vengono tutte rifiutate
        con questo messaggio, quindi crea una chiave e concedi l'autorizzazione
        in modo esplicito. Il rifiuto avviene prima di qualsiasi ricerca, quindi
        non dice nulla sull'esistenza di un oggetto.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            Bank data not allowed:
              summary: Accesso ai dati bancari non consentito
              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: >-
        Si è verificato un problema lato Didit. Qualsiasi errore imprevisto
        sotto `/v3/bank/` risponde nel formato di errore Bank, mai con una
        pagina HTML: indica `request_id` al supporto.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/BankDataError'
          examples:
            Internal error:
              summary: Un errore imprevisto
              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 chiave API della tua applicazione, da Developers -> API keys nella
        Business Console. La chiave primaria ha accesso completo. Una chiave con
        nome può avere ambiti limitati: nessuno, lettura o scrittura per
        risorsa, limitata ad alcuni workflow o solo alle sessioni approvate, a
        un elenco di indirizzi IP e a una data di scadenza. 401 significa che la
        chiave è errata, revocata o scaduta; 403 significa che non è stata
        inviata alcuna chiave, che la chiave non ha accesso a questa risorsa o
        azione, oppure che la richiesta proviene da un indirizzo esterno alla
        sua lista IP; 404 su una route di sessione significa che la sessione è
        al di fuori dei workflow o degli stati consentiti alla chiave. Una
        chiave senza accesso ai media riceve gli URL di immagini, video e PDF
        come null, e una chiave senza permesso di scrittura sulle sessioni
        riceve i link e i token delle sessioni come null. Vedi
        https://docs.didit.me/console/api-keys.

````

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