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

# Esporta cronologia screening AML in CSV: API Didit

> Scarica in CSV la cronologia del monitoraggio AML continuo di una sessione, una riga per ogni nuovo screening completato, pronta per l'auditor. Con Didit.

Prompt API per esportare lo storico degli screening AML
Copia il prompt negli appunti

<pre>
  \`Download the ongoing AML monitoring history of one Didit verification session as a CSV file through the API.

  Endpoint:
  GET [https://verification.didit.me/v3/session/\{session\_id}/aml-screening-history/export/](https://verification.didit.me/v3/session/\{session_id}/aml-screening-history/export/)

  Authentication:
  Send my Didit API key in the x-api-key header. A scoped key needs decisions: read and media: read (the response is a file; without media: read the call returns 403).

  Goal:

  * Produce the audit evidence that ongoing AML monitoring ran for a subject, as a file a compliance team can hand to an auditor.

  Query parameters:

  * node\_id (optional): the workflow node ID of the AML check when the session ran several AML steps. Without it, the most recent AML check is used.

  Behavior:

  * Works for user (KYC) and business (KYB) session IDs.
  * Streams text/csv with Content-Disposition: attachment; filename="aml-screening-history-SESSION\_ID.csv". Not paginated: the file holds the whole history, newest first.
  * The first line is the header. Each following line is one completed re-screen.
  * Columns: screened\_at, outcome, provider, aml\_status, aml\_score, total\_hits, datasets\_captured\_at, datasets\_sanctions\_last\_updated\_at, datasets\_pep\_last\_updated\_at, datasets\_warnings\_last\_updated\_at, datasets\_adverse\_media\_last\_updated\_at, datasets\_catalog\_version.
  * Empty cell = unknown. Dataset dates are never estimated.
  * provider is an identifier of the data source; treat it as an opaque string.
  * Values that would start a spreadsheet formula (=, +, -, @) are prefixed with an apostrophe.
  * Errors come back as JSON, not CSV.

  Example call:
  curl -X GET "[https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/aml-screening-history/export/](https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/aml-screening-history/export/)" \
  -H "x-api-key: YOUR\_API\_KEY" \
  -o aml-screening-history.csv

  Failure modes:

  * 401: the API key has expired.
  * 403: missing key (a wrong, revoked or expired key gets 401), a key of another application, a scoped key without decisions: read or media: read, or a request from outside the key's IP allowlist.
  * 404: the session does not exist, was deleted, or is outside a scoped key's limits, or it has no AML check (for that node\_id).

  Side effects: none. This is a pure read.

  For the full integration shape, see /integration/integration-prompt.\`
</pre>

Incolla in

Il file contiene gli stessi screening di [Elenca lo storico degli screening AML](https://docs.didit.me/it/management-api/sessions/aml-screening-history.md), con ogni screening su una sola riga e, dove disponibile, la data di aggiornamento del dataset di ciascuna famiglia di liste (sanzioni, PEP, avvisi, notizie negative). La Business Console offre la stessa esportazione accanto al risultato AML. Per il significato di ciascun valore, consulta [Monitoraggio AML continuo](https://docs.didit.me/it/core-technology/aml-screening/continuous-monitoring-aml-screening.md).


## OpenAPI

````yaml it/openapi-25.json GET /v3/session/{sessionId}/aml-screening-history/export/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API di verifica dell'identità. Autenticati con l'intestazione x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/session/{sessionId}/aml-screening-history/export/:
    get:
      tags:
        - Sessions
      summary: Esportare la cronologia dello screening AML in formato CSV
      description: >-
        Scarica la stessa cronologia del monitoraggio continuo di `GET
        /v3/session/{sessionId}/aml-screening-history/` come file CSV, una riga
        per ogni nuovo screening completato, dalla più recente alla più vecchia,
        pronta da consegnare a un auditor. Il file viene trasmesso per intero
        (senza paginazione) e inizia con una riga di intestazione; una cella
        vuota indica un valore sconosciuto, le date dei dataset non vengono mai
        stimate e un valore che inizierebbe una formula di foglio di calcolo è
        preceduto da un apostrofo. Funziona per ID sessione KYC e KYB; passa
        `node_id` quando la sessione ha eseguito più di un passaggio AML. Passa
        `month` per esportare un mese di calendario. Gli errori vengono
        restituiti in formato JSON, non CSV. Una chiave API con ambito limitato
        richiede `decisions: read` e `media: read`: la risposta è un file,
        quindi una chiave senza `media: read` riceve `403`.
      operationId: get_v3_session_aml_screening_history_export
      parameters:
        - name: sessionId
          in: path
          required: true
          description: >-
            UUID della sessione di verifica (il `session_id` restituito da `POST
            /v3/session/`). Accetta sia ID di sessione di Verifica degli utenti
            (KYC) sia di Verifica aziendale (KYB): il server risolve l'ID per
            entrambi i tipi di sessione. Deve essere un UUID ben formato; un
            valore malformato non corrisponde alla route e restituisce una
            pagina HTML `404`.
          schema:
            type: string
            format: uuid
            example: 11111111-2222-3333-4444-555555555555
        - name: node_id
          in: query
          required: false
          description: >-
            ID del nodo del grafo del workflow relativo al controllo AML.
            Necessario solo se la sessione ha eseguito più di un passaggio AML;
            in sua assenza viene utilizzato il controllo AML più recente. Un
            nodo sconosciuto restituisce `404`.
          schema:
            type: string
            example: feature_aml_1
        - name: month
          in: query
          required: false
          description: >-
            Un mese di calendario UTC nel formato `YYYY-MM`. Vengono restituiti
            solo gli screening completati in quel mese; senza di esso vengono
            restituiti i dati di ogni mese. Un mese con formato errato
            restituisce `400`.
          schema:
            type: string
            pattern: ^\d{4}-(0[1-9]|1[0-2])$
            example: 2026-09
      responses:
        '200':
          description: >-
            Il file CSV, trasmesso in streaming come `text/csv` con interruzioni
            di riga CRLF. Colonne, nell'ordine: `screened_at` (quando è
            terminato il nuovo screening), `outcome` (`NO_CHANGE`, `CHANGED` o
            `FAILED`), `provider` (identificatore opaco della fonte dati AML;
            non basare logica condizionale su di esso), `aml_status`,
            `aml_score`, `total_hits`, `datasets_captured_at`,
            `datasets_sanctions_last_updated_at`,
            `datasets_pep_last_updated_at`, `datasets_warnings_last_updated_at`,
            `datasets_adverse_media_last_updated_at`,
            `datasets_catalog_version`, `run_id` (l'esecuzione del
            monitoraggio), `entities_screened` (`1`, o `0` per un'esecuzione non
            riuscita) e `new_hits` (vuoto se sconosciuto). Le date sono in
            formato ISO 8601 con offset UTC. Una sessione che non ha ancora
            nuovi screening restituisce solo la riga di intestazione.
          headers:
            Content-Disposition:
              description: >-
                `attachment; filename="aml-screening-history-{sessionId}.csv"`,
                oppure `aml-screening-history-{sessionId}-{month}.csv` quando
                viene passato `month`.
              schema:
                type: string
                example: >-
                  attachment;
                  filename="aml-screening-history-11111111-2222-3333-4444-555555555555.csv"
          content:
            text/csv:
              schema:
                type: string
                format: binary
              example: "screened_at,outcome,provider,aml_status,aml_score,total_hits,datasets_captured_at,datasets_sanctions_last_updated_at,datasets_pep_last_updated_at,datasets_warnings_last_updated_at,datasets_adverse_media_last_updated_at,datasets_catalog_version,run_id,entities_screened,new_hits\r\n2026-09-14T04:12:33.481207+00:00,NO_CHANGE,aml_data_source,Approved,0.0,0,2026-09-14T03:58:02.114820+00:00,2026-09-13T21:10:00+00:00,2026-09-13T08:00:00+00:00,2026-09-12T18:45:00+00:00,,2026-09-13,aaaaaaaa-1111-2222-3333-444444444444,1,0\r\n2026-09-13T04:11:58.020914+00:00,FAILED,aml_data_source,Approved,0.0,0,,,,,,,bbbbbbbb-1111-2222-3333-444444444444,0,\r\n"
        '400':
          description: '`month` non è un mese di calendario `YYYY-MM`.'
          content:
            application/json:
              schema:
                type: object
                properties:
                  month:
                    type: array
                    items:
                      type: string
              examples:
                Malformed month:
                  summary: month=2026-13
                  value:
                    month:
                      - Not a calendar month. Use YYYY-MM.
        '401':
          description: >-
            La chiave API con ambito è scaduta. Questo è l'unico caso che
            restituisce `401`: una chiave mancante, non valida o revocata
            restituisce `403`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Messaggio di errore di facile lettura.
              examples:
                Expired key:
                  summary: La data di scadenza della chiave è stata superata
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            Errore di autenticazione o autorizzazione. Una chiave mancante
            restituisce `403`, così come la chiave di un'altra applicazione, una
            chiave con ambito limitato priva dell'autorizzazione necessaria per
            questo endpoint e una richiesta proveniente dall'esterno
            dell'allowlist IP della chiave; una chiave errata, revocata o
            scaduta restituisce `401`. Distinguili tramite `detail`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Messaggio di errore di facile lettura.
              examples:
                Missing or invalid credentials:
                  summary: >-
                    Nessuna intestazione x-api-key, oppure validazione della
                    chiave non riuscita
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Other application:
                  summary: >-
                    Una chiave valida appartenente a un'applicazione diversa da
                    quella della sessione
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without decisions read:
                  summary: 'La chiave con ambito non dispone di decisions: read'
                  value:
                    detail: This API key has no read access to decisions.
                Scoped key without media read:
                  summary: >-
                    La chiave con ambito non dispone di media: read (la risposta
                    è un file)
                  value:
                    detail: This API key has no read access to media.
                IP not allowed:
                  summary: >-
                    Richiesta proveniente da un indirizzo esterno all'allowlist
                    degli IP della chiave
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            La sessione non esiste, è stata eliminata o non rientra nei limiti
            di una chiave con ambito limitato, oppure non presenta alcun
            controllo AML (per il `node_id` specificato). La ricerca della
            sessione viene eseguita prima della verifica delle credenziali,
            quindi un `sessionId` sconosciuto restituisce `404` anche senza una
            chiave valida.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Messaggio di errore di facile lettura.
              examples:
                Unknown session:
                  summary: >-
                    Nessuna sessione con questo ID esiste, oppure è stata
                    eliminata
                  value:
                    detail: Not found.
                Outside key limits:
                  summary: >-
                    La sessione non rientra nei limiti di una chiave con ambito
                    limitato (restituito anche per una sessione eliminata pochi
                    istanti prima)
                  value:
                    detail: Session not found.
                No AML check:
                  summary: La sessione non ha mai eseguito un passaggio AML
                  value:
                    detail: The session does not have an AML check.
                No AML check for node:
                  summary: node_id non corrisponde a un controllo AML della sessione
                  value:
                    detail: >-
                      The session does not have an AML check for node
                      'feature_aml_2'.
        '429':
          description: >-
            Limite di frequenza superato: 600 richieste GET al minuto per chiave
            API. Attendi `Retry-After` secondi prima di riprovare; le
            intestazioni `X-RateLimit-*` mostrano il budget.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Messaggio di errore di facile lettura.
              examples:
                Rate limited:
                  summary: Budget per il minuto corrente esaurito
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
          headers:
            Retry-After:
              description: Secondi da attendere prima di effettuare un nuovo tentativo.
              schema:
                type: integer
                minimum: 1
                example: 30
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/aml-screening-history/export/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -o aml-screening-history.csv
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            content = client.sessions.export_aml_screening_history(
                "11111111-2222-3333-4444-555555555555",
            )
            with open("download.csv", "wb") as file:
                file.write(content)
        - lang: javascript
          label: Node.js
          source: >-
            import { writeFile } from "node:fs/promises";

            import Didit from "@didit-protocol/sdk-node";


            // Reads DIDIT_API_KEY.

            const didit = new Didit();


            const content = await
            didit.sessions.exportAmlScreeningHistory("11111111-2222-3333-4444-555555555555");

            await writeFile("download.csv", Buffer.from(await
            content.arrayBuffer()));
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresp, err := client.Sessions.ExportAMLScreeningHistory(ctx, \"11111111-2222-3333-4444-555555555555\", didit.SessionsExportAMLScreeningHistoryParams{})\nif err != nil {\n\tlog.Fatal(err)\n}\ndefer resp.Body.Close()\nfile, err := os.Create(\"download.csv\")\nif err != nil {\n\tlog.Fatal(err)\n}\ndefer file.Close()\nif _, err := io.Copy(file, resp.Body); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: >-
            import java.nio.file.Path;

            import me.didit.Didit;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            client.sessions().exportAmlScreeningHistory("11111111-2222-3333-4444-555555555555")
                    .writeTo(Path.of("download.csv"));
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $content =
            $didit->sessions->exportAmlScreeningHistory('11111111-2222-3333-4444-555555555555');

            $content->saveTo('download.csv');
        - lang: ruby
          label: Ruby
          source: >-
            require "didit"


            # Reads DIDIT_API_KEY.

            didit = Didit::Client.new


            content =
            didit.sessions.export_aml_screening_history("11111111-2222-3333-4444-555555555555")

            File.binwrite("download.csv", content)
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var content = await
            client.Sessions.ExportAmlScreeningHistoryAsync("11111111-2222-3333-4444-555555555555");

            await content.SaveToAsync("download.csv");
components:
  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 un ambito definito: nessuno, lettura o scrittura per
        risorsa, limitata ad alcuni workflow o a sessioni approvate, a un elenco
        di indirizzi IP e a una data di scadenza. 401 indica che la chiave è
        errata, revocata o scaduta; 403 indica 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 non incluso nel suo elenco IP;
        404 su una route di sessione indica che la sessione non rientra nei
        workflow o negli stati previsti dalla chiave. Una chiave senza accesso
        ai media riceve gli URL di immagini, video e PDF come null, e una chiave
        senza permessi di scrittura sulle sessioni riceve link e token di
        sessione come null. Consulta https://docs.didit.me/console/api-keys.

````

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