> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# API per creare un collegamento bancario: collegare o rinnovare una banca

> Didit: l'endpoint Create a Bank Link avvia un'esecuzione di Bank Link sul tuo server e restituisce l'url ospitato per collegare una banca.

L'endpoint Create a Bank Link avvia un'esecuzione di Bank Link sul tuo server, per collegare una banca o rinnovare una connessione, e restituisce l'`url` ospitato.
Ogni campo ha un valore predefinito, quindi la richiesta più semplice è `{}` più ciò che ti serve.
Conserva l'`id` restituito associato al tuo utente e verifica tu stesso l'esito con [Ottieni un link bancario](https://docs.didit.me/it/standalone-apis/bank-link-get.md) oppure con il webhook `bank.link.completed`.
Vedi la [guida rapida](https://docs.didit.me/it/core-technology/bank-verification/quickstart.md) e [Bank Link](https://docs.didit.me/it/core-technology/bank-verification/bank-link.md).


## OpenAPI

````yaml it/openapi-25.json POST /v3/bank/links/
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/links/:
    post:
      tags:
        - Bank Data
      summary: Crea un collegamento bancario
      description: >-
        Crea un Bank Link: un'esecuzione del flusso in cui una persona collega
        una banca oppure rinnova una connessione. Invia la persona a `url`. Il
        `client_token` è per il Bank Link incorporato di Didit, che non è ancora
        disponibile: apri oggi `url`. Un link completato produce una
        connessione.


        La richiesta minima è `{}` più ciò che vuoi. Valori predefiniti: `mode`
        connect, `access` one_time, `data` solo conti (accounts), `history_days`
        90, `ownership.compare` none, `segment` any, `duplicates` reuse,
        `allow_one_time_fallback` false e, per l'accesso continuo, un consenso
        valido finché la banca lo consente.


        La risposta contiene il preventivo: il prezzo è associato al link e
        addebitato secondo il preventivo. La chiave API non raggiunge mai un
        browser o un'app: vi arriva solo `url`.


        Verifica tu stesso il risultato con `get_link` o con il webhook
        `bank.link.completed`; non fidarti mai di un id di link inviato dal
        browser. Storico: invia `history_from` oppure `history_days`, non
        entrambi. Dove la banca lo consente, l'accesso continuo resta attivo
        fino alla fine del consenso; la data effettiva è indicata su ogni
        connessione.


        Richiede 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`.
      operationId: createBankLink
      parameters:
        - $ref: '#/components/parameters/IdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankLinkCreateRequest'
            example:
              mode: connect
              access: ongoing
              country: ESP
              segment: business
              data:
                - accounts
                - balances
                - transactions
              history_from: '2026-01-01'
              consent_days: 180
              ownership:
                compare: none
              end_user:
                reference: client-7731
                email: ana@example.com
              redirect_url: https://app.example.com/bank/return
              allowed_origins:
                - https://app.example.com
              language: es
              vendor_data: client-7731
      responses:
        '201':
          description: Il link è stato creato.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankLink'
              examples:
                Ongoing business connection:
                  summary: Accesso continuo per un conto aziendale in Spagna
                  value:
                    id: 0b9c4f1e-6a2d-4e8b-9f31-7c5d2e1a8b40
                    mode: connect
                    access: ongoing
                    status: created
                    url: https://verify.didit.me/bank/link/example-link-token
                    client_token: example-client-token
                    expires_at: '2026-11-21T13:00:00Z'
                    connection_id: null
                    check_id: null
                    reused: false
                    error: null
                    quote:
                      id: 7a3e9c52-1d84-4b06-8f2a-c5e0b9d17a43
                      lines:
                        - meter: bank_data_connection_month
                          unit: connection_month
                          price_usd: '0.9000'
                      fallback_lines: null
                      total_usd: '0.9000'
                      valid_until: '2026-11-21T13:00:00Z'
                      scopes:
                        - accounts
                        - balances
                        - transactions
                    vendor_data: client-7731
        '400':
          description: >-
            La richiesta è stata rifiutata prima di qualsiasi schermata. `field`
            indica cosa correggere: `invalid_request` per un valore fuori
            dall'intervallo o una combinazione non consentita, e i codici più
            specifici mostrati qui.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Bank cannot keep access open:
                  summary: La banca non può mantenere aperto l'accesso
                  value:
                    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
                History window ambiguous:
                  summary: Finestra storica ambigua
                  value:
                    code: history_window_ambiguous
                    message: Send history_from or history_days, not both.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: history_from
                    next_action: null
                    retry_after: null
                Redirect URL not registered:
                  summary: URL di reindirizzamento non registrato
                  value:
                    code: redirect_url_not_registered
                    message: >-
                      This redirect_url is not one of the return addresses
                      registered for your application. Addresses are matched
                      exactly (scheme, host, port, path and query); in sandbox a
                      plain http localhost address needs no registration. Send a
                      registered address, or leave redirect_url out (automatic
                      return to your page is then not promised).
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: redirect_url
                    next_action: null
                    retry_after: null
                Segment not available:
                  summary: Segmento non disponibile
                  value:
                    code: segment_not_available
                    message: >-
                      This bank does not offer this kind of account through Bank
                      Link.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: segment
                    next_action: null
                    retry_after: null
                Window not available:
                  summary: Finestra non disponibile
                  value:
                    code: window_not_available
                    message: This bank cannot deliver the requested history window.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: history_from
                    next_action: null
                    retry_after: null
                Invalid request:
                  summary: Richiesta non valida
                  value:
                    code: invalid_request
                    message: The request is not valid.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: expires_in
                    next_action: null
                    retry_after: null
        '401':
          $ref: '#/components/responses/Unauthorized'
        '402':
          description: Il saldo non copre il prezzo indicato. Ricarica, quindi riprova.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                Insufficient credits:
                  summary: Crediti insufficienti
                  value:
                    code: insufficient_credits
                    message: The balance cannot cover the quoted price.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: top_up_balance
                    retry_after: null
        '403':
          description: >-
            Rifiutato: il tuo contratto non prevede una tariffa per questo
            paese, oppure la chiave non ha l'autorizzazione per i dati bancari.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankDataError'
              examples:
                No contract rate:
                  summary: Nessuna tariffa contrattuale
                  value:
                    code: contract_rate_missing
                    message: Your contract has no rate for bank data in this country.
                    request_id: 3f6a1c8e-92b5-4d07-a1e3-8c4b7f0d2e59
                    field: null
                    next_action: null
                    retry_after: null
                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
        '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
        '429':
          $ref: '#/components/responses/RateLimitedWrite'
        '500':
          $ref: '#/components/responses/BankDataInternalError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST 'https://verification.didit.me/v3/bank/links/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "mode": "connect",
                "access": "ongoing",
                "country": "ESP",
                "segment": "business",
                "data": [
                  "accounts",
                  "balances",
                  "transactions"
                ],
                "history_from": "2026-01-01",
                "consent_days": 180,
                "ownership": {
                  "compare": "none"
                },
                "end_user": {
                  "reference": "client-7731",
                  "email": "ana@example.com"
                },
                "redirect_url": "https://app.example.com/bank/return",
                "allowed_origins": [
                  "https://app.example.com"
                ],
                "language": "es",
                "vendor_data": "client-7731"
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.create_link(
                mode="connect",
                access="ongoing",
                country="ESP",
                segment="business",
                data=["accounts", "balances", "transactions"],
                history_from="2026-01-01",
                consent_days=180,
                ownership={
                    "compare": "none",
                },
                end_user={
                    "reference": "client-7731",
                    "email": "ana@example.com",
                },
                redirect_url="https://app.example.com/bank/return",
                allowed_origins=["https://app.example.com"],
                language="es",
                vendor_data="client-7731",
            )
            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.createLink({
              mode: "connect",
              access: "ongoing",
              country: "ESP",
              segment: "business",
              data: ["accounts", "balances", "transactions"],
              history_from: "2026-01-01",
              consent_days: 180,
              ownership: {
                compare: "none",
              },
              end_user: {
                reference: "client-7731",
                email: "ana@example.com",
              },
              redirect_url: "https://app.example.com/bank/return",
              allowed_origins: ["https://app.example.com"],
              language: "es",
              vendor_data: "client-7731",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.CreateLink(ctx, didit.BankCreateLinkParams{\n\tBody: didit.BankLinkCreateRequest{\n\t\tMode:        didit.Some(didit.BankLinkCreateRequestMode(\"connect\")),\n\t\tAccess:      didit.Some(didit.BankLinkCreateRequestAccess(\"ongoing\")),\n\t\tCountry:     didit.String(\"ESP\"),\n\t\tSegment:     didit.Some(didit.BankLinkCreateRequestSegment(\"business\")),\n\t\tData:        didit.Some([]didit.BankLinkCreateRequestData{\"accounts\", \"balances\", \"transactions\"}),\n\t\tHistoryFrom: didit.String(\"2026-01-01\"),\n\t\tConsentDays: didit.Int(180),\n\t\tOwnership: didit.Some(didit.BankLinkOwnershipRequest{\n\t\t\tCompare: didit.Some(didit.BankLinkOwnershipRequestCompare(\"none\")),\n\t\t}),\n\t\tEndUser: didit.Some(didit.BankLinkEndUser{\n\t\t\tReference: didit.String(\"client-7731\"),\n\t\t\tEmail:     didit.String(\"ana@example.com\"),\n\t\t}),\n\t\tRedirectURL:    didit.String(\"https://app.example.com/bank/return\"),\n\t\tAllowedOrigins: didit.Some([]string{\"https://app.example.com\"}),\n\t\tLanguage:       didit.String(\"es\"),\n\t\tVendorData:     didit.String(\"client-7731\"),\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.time.LocalDate;

            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.BankLinkCreateRequest;

            import me.didit.types.BankLinkEndUser;

            import me.didit.types.BankLinkOwnershipRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().createLink(BankLinkCreateRequest.builder()
                    .mode(BankLinkCreateRequest.Mode.of("connect"))
                    .access(BankLinkCreateRequest.Access.of("ongoing"))
                    .country("ESP")
                    .segment(BankLinkCreateRequest.Segment.of("business"))
                    .data(List.of(BankLinkCreateRequest.Data.of("accounts"), BankLinkCreateRequest.Data.of("balances"), BankLinkCreateRequest.Data.of("transactions")))
                    .historyFrom(LocalDate.parse("2026-01-01"))
                    .consentDays(180L)
                    .ownership(BankLinkOwnershipRequest.builder()
                            .compare(BankLinkOwnershipRequest.Compare.of("none"))
                            .build())
                    .endUser(BankLinkEndUser.builder()
                            .reference("client-7731")
                            .email("ana@example.com")
                            .build())
                    .redirectUrl("https://app.example.com/bank/return")
                    .allowedOrigins(List.of("https://app.example.com"))
                    .language("es")
                    .vendorData("client-7731")
                    .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->createLink([
                'mode' => 'connect',
                'access' => 'ongoing',
                'country' => 'ESP',
                'segment' => 'business',
                'data' => ['accounts', 'balances', 'transactions'],
                'history_from' => '2026-01-01',
                'consent_days' => 180,
                'ownership' => [
                    'compare' => 'none',
                ],
                'end_user' => [
                    'reference' => 'client-7731',
                    'email' => 'ana@example.com',
                ],
                'redirect_url' => 'https://app.example.com/bank/return',
                'allowed_origins' => ['https://app.example.com'],
                'language' => 'es',
                'vendor_data' => 'client-7731',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.bank.create_link(
              mode: "connect",
              access: "ongoing",
              country: "ESP",
              segment: "business",
              data: ["accounts", "balances", "transactions"],
              history_from: "2026-01-01",
              consent_days: 180,
              ownership: {
                compare: "none",
              },
              end_user: {
                reference: "client-7731",
                email: "ana@example.com",
              },
              redirect_url: "https://app.example.com/bank/return",
              allowed_origins: ["https://app.example.com"],
              language: "es",
              vendor_data: "client-7731"
            )
            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.CreateLinkAsync(new
            BankLinkCreateRequest

            {
                Mode = new BankLinkCreateRequestMode("connect"),
                Access = new BankLinkCreateRequestAccess("ongoing"),
                Country = "ESP",
                Segment = new BankLinkCreateRequestSegment("business"),
                Data = new BankLinkCreateRequestData[] { "accounts", "balances", "transactions" },
                HistoryFrom = "2026-01-01",
                ConsentDays = 180,
                Ownership = new BankLinkOwnershipRequest
                {
                    Compare = new BankLinkOwnershipRequestCompare("none"),
                },
                EndUser = new BankLinkEndUser
                {
                    Reference = "client-7731",
                    Email = "ana@example.com",
                },
                RedirectUrl = "https://app.example.com/bank/return",
                AllowedOrigins = new string[] { "https://app.example.com" },
                Language = "es",
                VendorData = "client-7731",
            });

            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:
    BankLinkCreateRequest:
      type: object
      description: >-
        Crea un Bank Link. La richiesta minima è `{}` più ciò che vuoi: ogni
        campo ha un valore predefinito.
      properties:
        mode:
          type: string
          enum:
            - connect
            - renew
          description: >-
            `connect` (predefinito) crea una nuova connessione. `renew` richiede
            `connection_id` e riutilizza le impostazioni di quella connessione.
          default: connect
        connection_id:
          type: string
          description: 'La connessione da rinnovare. Solo con `mode: renew`.'
          format: uuid
        access:
          type: string
          enum:
            - one_time
            - ongoing
          description: >-
            `one_time` (predefinito) legge i dati una sola volta. `ongoing`
            mantiene aperto l'accesso finché il consenso non termina o qualcuno
            non lo interrompe. Con `institution_id` impostato, una banca che non
            può mantenere aperto l'accesso restituisce `400
            ongoing_access_not_available` prima di qualsiasi schermata. Senza di
            esso, il selettore delle banche elenca solo quelle che lo
            consentono.
          default: one_time
        country:
          type: string
          description: >-
            Facoltativo. Senza questo campo, la persona sceglie tra i paesi
            abilitati nella tua applicazione. Deve essere un paese servito da
            Bank Link; qualsiasi altro, incluso `ZZZ`, restituisce `400
            invalid_request` con `field: country`. Un corpo di richiesta vuoto
            resta valido.
          pattern: ^[A-Z]{3}$
        institution_id:
          type: string
          description: >-
            Banca facoltativa da preselezionare, da `list_institutions`. Salta
            il selettore.
          maxLength: 64
        segment:
          type: string
          enum:
            - personal
            - business
            - any
          description: >-
            Filtra il selettore e indica alla banca quale accesso aprire nei
            casi in cui la banca li distingue. Predefinito `any`.
          default: any
        data:
          type: array
          items:
            type: string
            enum:
              - accounts
              - balances
              - transactions
          description: >-
            Cosa leggere. `accounts` è sempre incluso: nome, tipo, valuta,
            identificativi e nome del titolare, dove la banca lo condivide.
            Predefinito `["accounts"]`.
          default:
            - accounts
          maxItems: 3
        history_days:
          type: integer
          description: >-
            Giorni di storico delle transazioni da richiedere, da 1 a 365, con
            valore predefinito 90. La banca potrebbe fornirne meno: ogni conto
            riporta in `history_coverage` quanto ha effettivamente fornito. Non
            può essere inviato insieme a `history_from`.
          minimum: 1
          maximum: 365
          default: 90
        history_from:
          type: string
          description: >-
            Data di inizio della cronologia da richiedere, al posto di
            `history_days`. Non può essere inviata insieme a `history_days`:
            l'invio di entrambi i parametri risponde `400
            history_window_ambiguous`. Una data più vecchia di 365 giorni, o
            futura, risponde `400 window_not_available`.
          format: date
        extended_history:
          type: string
          enum:
            - standard
            - allow_extra_auth
          description: >-
            `allow_extra_auth` consente a una banca che chiede un'ulteriore
            conferma di rilasciare lo storico più datato.
          default: standard
        consent_days:
          type: integer
          description: >-
            Solo per accesso continuo. Quanti giorni chiedere alla banca di
            mantenere aperto l'accesso, 1 o più. Predefinito: il periodo più
            lungo consentito dalla banca. La connessione riporta in
            `consent.expires_at` la data che la banca ha effettivamente
            concessa. Con `access: one_time` restituisce `400 invalid_request`
            con `field: consent_days`.
          minimum: 1
          maximum: 32767
        ownership:
          $ref: '#/components/schemas/BankLinkOwnershipRequest'
        end_user:
          $ref: '#/components/schemas/BankLinkEndUser'
        redirect_url:
          type: string
          description: >-
            Dove va il browser alla fine, con `link_id`, `status` e uno `state`
            firmato (solo per la visualizzazione: il webhook e `get_link` sono
            quelli autorevoli). In un'applicazione sandbox un indirizzo `http`
            semplice di `localhost`, `127.0.0.1` o `[::1]` (qualsiasi porta e
            percorso, senza credenziali, senza frammento) non richiede
            registrazione. Qualsiasi altro indirizzo restituisce `400
            redirect_url_not_registered`: la registrazione di altri indirizzi
            non è ancora disponibile. Senza `redirect_url` la persona termina
            sulla pagina dei risultati di Didit.
          format: uri
          maxLength: 2048
        allowed_origins:
          type: array
          items:
            type: string
            format: uri
          description: >-
            Accettato ma non usato oggi: riservato alla Bank Link integrata di
            Didit, che non è ancora disponibile. Origini HTTPS, fino a 50.
          maxItems: 50
        language:
          type: string
          description: >-
            Codice lingua facoltativo, come `es` o `pt-BR`. In assenza, viene
            usata la lingua del browser.
          pattern: ^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})?$
          maxLength: 16
        vendor_data:
          type: string
          description: Il tuo riferimento, restituito nel link e nella connessione.
          maxLength: 255
        expires_in:
          type: integer
          description: 'Durata del link in secondi, da 300 a 86400. Predefinita: 3600.'
          minimum: 300
          maximum: 86400
          default: 3600
        duplicates:
          type: string
          enum:
            - reuse
            - allow
          description: >-
            `reuse` (predefinito) completa un link che rimanda a conti già
            condivisi come rinnovo di quella connessione. `allow` crea una
            seconda connessione indipendente.
          default: reuse
        allow_one_time_fallback:
          type: boolean
          description: >-
            Con `ongoing`, consente alla persona di proseguire con una lettura
            una tantum presso una banca che non può mantenere aperto l'accesso,
            dopo aver confermato l'accesso ridotto nella propria schermata. Il
            preventivo mostra quanto costa. Solo con `access: ongoing`: con
            accesso una tantum restituisce `400 invalid_request` con `field:
            allow_one_time_fallback`.
          default: false
        accept_reduced_grant:
          type: boolean
          description: >-
            Quando la banca o la persona concede meno di quanto richiesto,
            completa il link e addebita solo gli ambiti concessi. Altrimenti il
            link termina con `failed` e `reduced_grant` e non viene addebitato
            nulla.
          default: false
        sandbox:
          type: object
          description: >-
            Solo per le applicazioni sandbox: seleziona il cliente Didit Test
            Bank. Viene ignorato in un'applicazione in produzione.
          properties:
            persona:
              type: string
              enum:
                - personal_basic
                - business_multi
                - long_history
                - pending
                - sparse_fields
                - no_ongoing
              description: >-
                Il cliente della Test Bank: `personal_basic` (un conto corrente,
                60 movimenti), `business_multi` (tre conti intestati a
                un'azienda), `long_history` (un conto con 400 giorni e 1.400
                movimenti; una lettura restituisce gli ultimi 365 giorni, quindi
                imposta `history_days` a 365), `pending` (include transazioni in
                sospeso), `sparse_fields` (senza data valuta, senza IBAN della
                controparte, senza riferimento bancario) oppure `no_ongoing`
                (una banca che consente solo l'accesso una tantum: usa
                `allow_one_time_fallback`).
            switches:
              type: array
              items:
                type: string
                enum:
                  - partial_grant
                  - renewal_other_login
                  - expired_cursor
                  - webhook_twice
                  - midnight_booking
                  - blocked_popup
                  - bank_app_return
              description: >-
                Accettato e riservato al simulatore sandbox: i valori oggi non
                cambiano nulla.
    BankLink:
      type: object
      description: >-
        Un'esecuzione di Bank Link per una persona: collega una banca oppure
        rinnova una connessione. Conferma tu stesso un link con `get_link`: non
        fidarti mai di un id inviato dal browser.
      properties:
        id:
          type: string
          description: Identificativo del link.
          format: uuid
        mode:
          type: string
          enum:
            - connect
            - renew
        access:
          type: string
          enum:
            - one_time
            - ongoing
        status:
          type: string
          enum:
            - created
            - opened
            - connecting
            - completed
            - cancelled
            - expired
            - failed
          description: >-
            Stato del link. `completed`, `cancelled`, `expired` e `failed` sono
            stati definitivi.
        url:
          type: string
          description: >-
            La pagina ospitata a cui inviare la persona. Restituita solo alla
            creazione del link; `null` nelle letture successive, perché il token
            non viene memorizzato.
          nullable: true
          format: uri
        client_token:
          type: string
          description: >-
            Il token per il Bank Link incorporato di Didit, che non è ancora
            disponibile: apri `url` oggi. Viene restituito solo alla creazione
            del link; `null` nelle letture successive. Ha uno scopo unico e una
            validità breve. Non contiene dati personali. Non registrarlo mai nei
            log.
          nullable: true
        expires_at:
          type: string
          description: Quando un link non riscattato smette di funzionare.
          format: date-time
        connection_id:
          type: string
          description: >-
            La connessione creata o rinnovata da questo link, quando `status` è
            `completed`.
          format: uuid
          nullable: true
        check_id:
          type: string
          description: >-
            L'esito dell'assetto proprietario di questo link, quando ha
            richiesto `ownership.compare` diverso da `none`.
          format: uuid
          nullable: true
        reused:
          type: boolean
          description: >-
            `true` quando il link è stato completato come rinnovo di una
            connessione esistente, perché la persona condivide già esattamente
            questi conti (`duplicates: reuse`). Nessun importo viene addebitato
            due volte.
        error:
          allOf:
            - $ref: '#/components/schemas/BankLinkError'
          nullable: true
          description: >-
            Perché il link non è riuscito, quando `status` è `failed`.
            Altrimenti `null`.
        quote:
          $ref: '#/components/schemas/BankLinkQuote'
        vendor_data:
          type: string
          description: Il tuo riferimento della richiesta.
          nullable: true
      required:
        - id
        - mode
        - access
        - status
        - url
        - client_token
        - expires_at
        - connection_id
        - check_id
        - reused
        - error
        - quote
        - vendor_data
    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
    BankLinkOwnershipRequest:
      type: object
      description: >-
        Confronto facoltativo del titolare del conto con una persona o
        un'azienda.
      properties:
        compare:
          type: string
          enum:
            - none
            - person
            - business
          description: >-
            Con cosa viene confrontato il titolare del conto. `none`
            (predefinito) non fornisce alcun esito e non richiede alcun
            riferimento. `person` richiede `reference_identity` o `session_id`.
            `business` richiede `business` o `business_session_id`. Invia
            esattamente un riferimento del tipo con cui effettui il confronto, e
            nessuno con `none`.
          default: none
        match:
          type: string
          enum:
            - any_holder
            - all_holders
          description: >-
            Se deve corrispondere un solo titolare legale o ogni titolare
            legale. I rappresentanti non vengono mai conteggiati.
          default: any_holder
        reference_identity:
          type: object
          description: >-
            Valori forniti dal chiamante da confrontare con il titolare del
            conto. Non possono essere inviati con `session_id`.
          properties:
            full_name:
              type: string
              maxLength: 255
            date_of_birth:
              type: string
              format: date
            address:
              type: string
              maxLength: 500
            phone:
              type: string
              maxLength: 64
            email:
              type: string
              maxLength: 255
        session_id:
          type: string
          description: >-
            Una sessione di verifica Didit completata della persona con cui
            confrontare. Non può essere inviata insieme a `reference_identity`.
          format: uuid
        business:
          type: object
          description: L'azienda da confrontare con il titolare del conto.
          properties:
            legal_name:
              type: string
              maxLength: 255
            registration_id:
              type: string
              maxLength: 128
          required:
            - legal_name
        business_session_id:
          type: string
          description: >-
            Una verifica aziendale (KYB) di Didit con cui confrontare. Non può
            essere inviata insieme a `business`.
          format: uuid
    BankLinkEndUser:
      type: object
      description: La persona o l'azienda che collega il conto.
      properties:
        reference:
          type: string
          description: >-
            Il tuo id per la persona o l'azienda. Ricercabile con
            `end_user_reference` e usato per riconoscere una connessione
            ripetuta.
          maxLength: 255
        email:
          type: string
          description: >-
            Facoltativo. Se il percorso bancario richiede un indirizzo
            verificato della persona e non ne hai inviato uno, Bank Link lo
            richiede alla persona. Non viene mai usato per scopi di marketing.
          format: email
          maxLength: 254
    BankLinkError:
      type: object
      description: >-
        Il motivo per cui un link è terminato con stato `failed`. Non è stato
        pubblicato né addebitato nulla.
      properties:
        code:
          type: string
          enum:
            - duplicate_conflict
            - renewal_login_mismatch
            - reduced_grant
            - corporate_approval_not_supported
            - ongoing_access_not_available
            - bank_unavailable
            - bank_cancelled
            - consent_declined
            - read_limit
            - renewal_not_needed
            - renewal_window_expired
            - first_sync_failed
          description: >-
            Perché il link non è riuscito. Un link non riuscito non è un errore
            HTTP: il link restituisce `status: failed` e questo oggetto. Un link
            di rinnovo la cui connessione nel frattempo è cambiata restituisce
            `renewal_not_needed` o `renewal_window_expired`.
        message:
          type: string
          description: Spiegazione in linguaggio semplice per uno sviluppatore.
        conflicts_with:
          type: array
          nullable: true
          items:
            type: string
            format: uuid
          description: >-
            Con `duplicate_conflict`: gli id delle connessioni attive che si
            sovrappongono. Rinnova una di esse oppure crea di nuovo il link con
            `duplicates: allow`.
      required:
        - code
        - message
        - conflicts_with
    BankLinkQuote:
      type: object
      description: >-
        Il prezzo di un link, fissato al momento della creazione. Il costo
        addebitato è quello del preventivo. Le letture non addebitano nulla.
      properties:
        id:
          type: string
          description: Identificativo del preventivo.
          format: uuid
        lines:
          type: array
          items:
            $ref: '#/components/schemas/BankLinkQuoteLine'
          description: Le voci che questo link addebita, per gli ambiti richiesti.
        fallback_lines:
          type: array
          nullable: true
          items:
            $ref: '#/components/schemas/BankLinkQuoteLine'
          description: >-
            Il costo di una lettura una tantum di riserva, mostrato solo quando
            il link è stato creato con `allow_one_time_fallback`. Compare nella
            risposta di creazione ed è `null` altrimenti. Una lettura una tantum
            con dati può costare più di un primo mese di accesso continuativo.
        total_usd:
          type: string
          description: >-
            Totale di `lines` in USD. Il totale può solo diminuire: con
            un'autorizzazione ridotta, o quando la persona sceglie un paese con
            un prezzo più basso.
          pattern: ^-?\d+(\.\d+)?$
        valid_until:
          type: string
          description: >-
            Il preventivo è associato al link e valido per tutta la durata del
            link, quindi coincide con `expires_at`.
          format: date-time
        scopes:
          type: array
          items:
            type: string
            enum:
              - accounts
              - balances
              - transactions
          description: I dati determinano i prezzi del preventivo.
      required:
        - id
        - lines
        - fallback_lines
        - total_usd
        - valid_until
        - scopes
    RateLimitBudgetError:
      type: object
      description: >-
        Restituito solo per un rifiuto del budget del middleware del limite di
        frequenza. Altri errori 429, inclusi i conflitti di idempotenza e i
        limiti specifici dell'endpoint, non garantiscono questi campi di
        metadati.
      required:
        - detail
        - reference
        - limit
        - remaining
        - reset
        - window_seconds
      properties:
        detail:
          type: string
          description: Messaggio di rifiuto per budget leggibile, già esistente.
        reference:
          type: string
          pattern: ^RL-[0-9a-f]{32}$
          description: >-
            Riferimento di supporto opaco: RL- seguito da 32 caratteri
            esadecimali minuscoli di un UUID.
        limit:
          type: integer
          description: Budget per l'ambito superato; equivale a X-RateLimit-Limit.
        remaining:
          type: integer
          minimum: 0
          description: Budget residuo, limitato a zero; equivale a X-RateLimit-Remaining.
        reset:
          type: integer
          format: int64
          description: >-
            Orario di reset della finestra in secondi Unix; coincide con
            X-RateLimit-Reset.
        window_seconds:
          type: integer
          description: >-
            Durata della finestra fissa in secondi, non il tempo di attesa
            residuo. Rispetta Retry-After prima di riprovare.
      example:
        detail: >-
          Write request rate limit exceeded. You can make up to 300 requests per
          minute.
        reference: RL-00000000000040008000000000000001
        limit: 300
        remaining: 0
        reset: 1794358860
        window_seconds: 60
    BankLinkQuoteLine:
      type: object
      description: Una voce con prezzo di un preventivo.
      properties:
        meter:
          type: string
          description: >-
            Cosa viene addebitato, ad esempio `bank_data_connection_month`,
            `bank_verification`.
          example: bank_data_connection_month
        unit:
          type: string
          description: Cos'è un'unità, ad esempio `connection_month` o `completed_sign_in`.
          example: connection_month
        price_usd:
          type: string
          description: >-
            Prezzo di un'unità in USD, stringa decimale con 4 decimali. Gli
            importi negli esempi sono indicativi; il prezzo per un paese è
            riportato nella pagina dei prezzi.
          pattern: ^-?\d+(\.\d+)?$
          example: '0.9000'
      required:
        - meter
        - unit
        - price_usd
  responses:
    Unauthorized:
      description: Non autorizzato
      content:
        application/json:
          examples:
            Invalid API Key:
              summary: Chiave API non valida
              value:
                detail: Invalid API Key.
    RateLimitedWrite:
      description: >-
        È stato superato il limite condiviso di scrittura di 300 richieste al
        minuto per chiave API. Rispetta `Retry-After` prima di riprovare.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RateLimitBudgetError'
          example:
            detail: >-
              Write request rate limit exceeded. You can make up to 300 requests
              per minute.
            reference: RL-00000000000040008000000000000001
            limit: 300
            remaining: 0
            reset: 1794358860
            window_seconds: 60
      headers:
        Retry-After:
          $ref: '#/components/headers/BudgetRetryAfter'
        X-RateLimit-Scope:
          $ref: '#/components/headers/BudgetXRateLimitScope'
        X-RateLimit-Limit:
          $ref: '#/components/headers/BudgetXRateLimitLimit'
        X-RateLimit-Remaining:
          $ref: '#/components/headers/BudgetXRateLimitRemaining'
        X-RateLimit-Reset:
          $ref: '#/components/headers/BudgetXRateLimitReset'
    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
  headers:
    BudgetRetryAfter:
      description: >-
        Secondi di attesa, arrotondati alla finestra successiva. Presente nei
        rifiuti per budget del middleware.
      schema:
        type: integer
    BudgetXRateLimitScope:
      description: >-
        L'ambito il cui budget è stato superato. Presente nei rifiuti per budget
        del middleware.
      schema:
        type: string
    BudgetXRateLimitLimit:
      description: >-
        Budget per l'ambito superato; equivale al limite nel corpo. Presente nei
        rifiuti per budget del middleware.
      schema:
        type: integer
    BudgetXRateLimitRemaining:
      description: >-
        Budget residuo, limitato a zero; equivale a remaining nel corpo.
        Presente nei rifiuti per budget del middleware.
      schema:
        type: integer
    BudgetXRateLimitReset:
      description: >-
        Orario di reset in secondi Unix; coincide con il reset nel corpo.
        Presente nei rifiuti per budget del middleware.
      schema:
        type: integer
  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.