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

# Eliminare una connessione bancaria API: revoca dell'accesso e cancellazione dei dati

> L'endpoint Didit per eliminare una connessione bancaria revoca l'accesso presso la banca e cancella conti, saldi e transazioni salvati.

L'endpoint di Didit per eliminare una connessione bancaria interrompe l'accesso presso la banca ed elimina i conti, i saldi e le transazioni memorizzati per la connessione.
L'eliminazione è irreversibile.
Per interrompere l'accesso senza eliminare, usa la [revoca](https://docs.didit.me/it/standalone-apis/bank-connection-revoke.md).
Consulta [Dati, consenso ed eliminazione](https://docs.didit.me/it/core-technology/bank-verification/data-consent-and-deletion.md) per sapere quali elementi sono interessati e quali no.


## OpenAPI

````yaml it/openapi-25.json DELETE /v3/bank/connections/{id}/
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}/:
    delete:
      tags:
        - Bank Data
      summary: Elimina una connessione bancaria
      description: >-
        Elimina i dati bancari della connessione e interrompe l'accesso presso
        la banca. Vengono eliminati i conti, i saldi, le transazioni, la
        cronologia delle sincronizzazioni, i registri del consenso e i risultati
        relativi all'assetto proprietario. L'eliminazione è irreversibile.


        L'operazione inizia subito: la risposta è `202` con `erasure.status`
        `pending`, e da quel momento le operazioni sui dati della connessione
        (aggiornamento, esecuzioni di sincronizzazione, conti, saldi,
        transazioni e feed delle modifiche) restituiscono `409
        connection_not_active`. La connessione viene poi letta con
        `erasure.status` `erased`, oppure `failed` se l'eliminazione non può
        essere confermata entro 24 ore; un'eliminazione non riuscita viene
        ritentata finché non si completa. Una connessione eliminata viene
        restituita come record minimo: il suo id, `status: deleted`, il motivo,
        le sue date e lo stato `erasure`, e non contiene conti, saldi,
        transazioni, dati di consenso o di sincronizzazione.


        Non sono interessate le altre connessioni, i costi già addebitati (che
        non vengono rimborsati) e i dati già scaricati, che sono una tua copia.
        Ripetere la chiamata restituisce lo stato attuale. Per interrompere
        l'accesso senza eliminare, usa `revoke_connection`.


        Richiede una chiave API con il permesso Bank data (`bank-data`):
        scrittura per questa operazione, che modifica qualcosa. Una chiave con
        accesso completo non include questo permesso: concedilo esplicitamente
        quando crei la chiave, altrimenti la chiamata restituisce `403
        bank_data_access_denied`.
      operationId: deleteBankConnection
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: L'id della connessione.
        - $ref: '#/components/parameters/IdempotencyKey'
      responses:
        '202':
          description: Eliminazione accettata.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankConnectionDeletion'
              examples:
                Accepted:
                  summary: Eliminazione in attesa
                  value:
                    id: 5e1d2a70-3b94-4c1f-8a6e-d2f07b9c1e35
                    erasure:
                      status: pending
                      requested_at: '2026-11-21T15:10:00Z'
                      erased_at: 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
        '429':
          $ref: '#/components/responses/RateLimitedWrite'
        '500':
          $ref: '#/components/responses/BankDataInternalError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X DELETE
            'https://verification.didit.me/v3/bank/connections/5e1d2a70-3b94-4c1f-8a6e-d2f07b9c1e35/'
            \
              -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.delete_connection(
                "11111111-2222-3333-4444-555555555555",
            )
            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.deleteConnection("11111111-2222-3333-4444-555555555555");

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


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().deleteConnection("11111111-2222-3333-4444-555555555555");

            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->deleteConnection('11111111-2222-3333-4444-555555555555');

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


            # Reads DIDIT_API_KEY.

            didit = Didit::Client.new


            result =
            didit.bank.delete_connection("11111111-2222-3333-4444-555555555555")

            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.DeleteConnectionAsync("11111111-2222-3333-4444-555555555555");

            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:
    BankConnectionDeletion:
      type: object
      description: >-
        Cancellazione accettata. I dati bancari della connessione sono in fase
        di eliminazione e le sue operazioni sui dati rispondono `409
        connection_not_active`; la lettura della connessione restituisce un
        record minimo con questo stato `erasure`.
      properties:
        id:
          type: string
          description: L'id della connessione.
          format: uuid
        erasure:
          $ref: '#/components/schemas/BankConnectionErasure'
      required:
        - id
        - erasure
    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
    BankConnectionErasure:
      type: object
      description: Avanzamento di una cancellazione richiesta da te.
      properties:
        status:
          type: string
          enum:
            - pending
            - erased
            - failed
          description: >-
            `pending` mentre l'eliminazione è in corso, `erased` quando non
            restano copie memorizzate né accessi presso la banca, `failed`
            quando non è stata confermata entro 24 ore. Un'eliminazione non
            riuscita mantiene inaccessibili i dati della connessione, viene
            ripetuta e Didit viene avvisato.
        requested_at:
          type: string
          format: date-time
        erased_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            Quando è terminata la cancellazione. `null` finché `status` non è
            `erased`.
      required:
        - status
        - requested_at
        - erased_at
    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
  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
    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.