> ## 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 de fraîcheur des données AML

> Vérifiez la fraîcheur des datasets Didit (sanctions, PEP, alertes, presse négative) par famille de sources : preuve d'audit pour la surveillance AML.



Invite de l'API de fraîcheur des jeux de données AML
        Copier le prompt dans le presse-papiers



      
      

\<pre>

\`Read how current Didit's AML screening datasets are, so I can attach it to an audit of ongoing AML monitoring.

Endpoint:
GET https://verification.didit.me/v3/aml/dataset-freshness/

Authentication:
Use the x-api-key header with my Didit API key. A scoped key needs sessions: read. A key limited to some workflows or to approved sessions can't call this endpoint.

Goal:
\- Get, per AML source family (sanctions, pep, warnings, adverse_media), the most recent dataset update and the staleness bound, and store it next to the AML screening history I hand to an auditor.

Behavior:
\- Platform-wide: no session in the path, no customer data in the answer, the same answer for every application.
\- Always 200. When no reading exists, dataset_freshness is null and availability says why: "not_configured" (dataset dates are not collected in this environment) or "not_yet_collected" (collection is set up, no reading yet).
\- Dates are never estimated. A family whose datasets reported no date is absent from sources. A family where only some datasets reported a date has oldest_updated_at: null.
\- captured_at is when the dates were read. Readings are taken while ongoing monitoring runs, not on each call.

Example call:
curl -X GET "https://verification.didit.me/v3/aml/dataset-freshness/" \
-H "x-api-key: YOUR_API_KEY"

What to read from the response:
\- availability - "available", "not_configured" or "not_yet_collected". Check it before reading dataset_freshness.
\- dataset_freshness.captured_at - when the reading was taken.
\- dataset_freshness.sources.<family>.last_updated_at - the most recent update in that family.
\- dataset_freshness.sources.<family>.oldest_updated_at - every dataset in the family is at least this current; null when some dates are missing.
\- dataset_freshness.sources.<family>.dataset_count and dated_dataset_count - how many datasets the family has and how many reported a date.
\- dataset_freshness.catalog_version - the data source's own catalog version, when reported.

Failure modes:
\- 401 - the API key has expired.
\- 403 - missing key (a wrong, revoked or expired key gets 401) ({"detail": "You do not have permission to perform this action."}), a scoped key without sessions: read, a key limited to workflows or approved sessions, or a request from outside the key's IP list.
\- 429 - more than 600 GET requests per minute with this key; wait Retry-After seconds.

Side effects: none. Not billed.

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

Coller dans

Utilisez cet endpoint pour afficher les versions des listes sur lesquelles la surveillance continue a effectué ses filtrages. Associez-le à l'historique de filtrage par sujet décrit dans [Preuve de l'exécution de la surveillance](https://docs.didit.me/fr/core-technology/aml-screening/continuous-monitoring-aml-screening.md#prouver-que-la-surveillance-a-bien-été-exécutée) : l'historique indique à quelle date chaque sujet a été filtré, et cet endpoint indique le niveau de mise à jour des jeux de données sur lesquels reposaient ces filtrages.> [!NOTE]
>
> Une date manquante est signalée comme manquante, jamais remplacée par une valeur de substitution. Vérifiez d'abord `availability` : lorsque sa valeur n'est pas `available`, `dataset_freshness` vaut `null` et il n'y a rien à lire.## Voir aussi- [Surveillance AML continue](https://docs.didit.me/fr/core-technology/aml-screening/continuous-monitoring-aml-screening.md)
- [API de filtrage AML](https://docs.didit.me/fr/standalone-apis/aml-screening.md)
- [Clés API et accès délimités](https://docs.didit.me/fr/console/api-keys.md)


## OpenAPI

````yaml fr/openapi-25.json GET /v3/aml/dataset-freshness/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/aml/dataset-freshness/:
    get:
      tags:
        - Standalone APIs
      summary: Obtenir la fraîcheur du jeu de données AML
      description: >-
        Indique la fraîcheur des jeux de données utilisés pour le filtrage AML,
        par famille de sources (`sanctions`, `pep`, `warnings`,
        `adverse_media`), comme élément d'audit pour la [surveillance AML
        continue](https://docs.didit.me/fr/core-technology/aml-screening/continuous-monitoring-aml-screening#prouver-que-la-surveillance-a-bien-été-exécutée).
        La réponse s'applique à l'ensemble de la plateforme : aucune session
        dans le chemin d'accès, aucune donnée client dans le corps, la même
        réponse pour chaque application.


        Renvoie systématiquement `200` pour une clé acceptée. Vérifiez
        `availability` en premier : lorsqu'elle ne vaut pas `available`,
        `dataset_freshness` est `null`. Les dates ne sont jamais estimées : une
        famille dont les jeux de données n'ont indiqué aucune date est absente
        de `sources`, et une famille où seuls certains jeux de données en ont
        indiqué une a `oldest_updated_at: null`. Les relevés sont effectués
        pendant l'exécution de la surveillance continue, pas à chaque appel ;
        `captured_at` indique la date du relevé.


        Une clé API restreinte nécessite `sessions: read` ; une clé limitée à
        certains workflows ou aux sessions approuvées ne peut pas appeler cet
        endpoint. Rien n'est facturé.
      operationId: get_aml_dataset_freshness
      parameters: []
      responses:
        '200':
          description: >-
            Le relevé le plus récent de fraîcheur du jeu de données, ou `null`
            avec la raison.
          content:
            application/json:
              schema:
                type: object
                required:
                  - dataset_freshness
                  - availability
                properties:
                  dataset_freshness:
                    allOf:
                      - $ref: '#/components/schemas/AMLDatasetFreshness'
                    nullable: true
                    description: >-
                      Le dernier relevé, ou `null` lorsque `availability` n'est
                      pas `available`.
                  availability:
                    type: string
                    enum:
                      - available
                      - not_configured
                      - not_yet_collected
                    description: >-
                      `available` lorsqu'un relevé existe ; `not_configured`
                      lorsque les dates du jeu de données ne sont pas collectées
                      dans cet environnement ; `not_yet_collected` lorsque la
                      collecte est configurée mais qu'aucun relevé n'existe
                      encore.
              examples:
                Available:
                  value:
                    dataset_freshness:
                      captured_at: '2026-10-17T06:00:12.345678+00:00'
                      provider: aml_data_source
                      catalog_version: 20261017054500-abc
                      sources:
                        sanctions:
                          last_updated_at: '2026-10-17T04:10:00+00:00'
                          oldest_updated_at: '2026-10-15T22:30:00+00:00'
                          dataset_count: 48
                          dated_dataset_count: 48
                        pep:
                          last_updated_at: '2026-10-16T23:05:00+00:00'
                          oldest_updated_at: null
                          dataset_count: 12
                          dated_dataset_count: 11
                    availability: available
                Not collected yet:
                  value:
                    dataset_freshness: null
                    availability: not_yet_collected
        '401':
          description: >-
            La clé API a expiré. Seule une clé créée avec une date d'expiration
            peut expirer ; après cette date, chaque requête effectuée avec
            celle-ci renvoie `401`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Expired key:
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            La requête n'est pas autorisée. Une clé manquante reçoit le message
            générique ; une clé erronée, révoquée ou expirée reçoit `401`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Missing or invalid key:
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without sessions read:
                  value:
                    detail: This API key has no read access to sessions.
                Key limited to workflows or approved sessions:
                  value:
                    detail: >-
                      This API key only reaches sessions inside its workflow or
                      status limits, so it can't use this endpoint.
                Outside the key's IP list:
                  value:
                    detail: This API key can't be used from this IP address.
        '429':
          description: >-
            Plus de 600 requêtes GET par minute avec cette clé API. Attendez le
            nombre de secondes indiqué dans `Retry-After`, puis réessayez.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Throttled:
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
          headers:
            Retry-After:
              description: >-
                Secondes avant la réinitialisation de la fenêtre actuelle d'une
                minute.
              schema:
                type: integer
                example: 23
            X-RateLimit-Limit:
              description: Requêtes autorisées par minute dans ce budget.
              schema:
                type: integer
            X-RateLimit-Remaining:
              description: Requêtes restantes dans la fenêtre actuelle.
              schema:
                type: integer
            X-RateLimit-Reset:
              description: Temps Unix auquel la fenêtre se réinitialise.
              schema:
                type: integer
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/aml/dataset-freshness/' \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.aml.retrieve_dataset_freshness()
            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.aml.retrieveDatasetFreshness();
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.AML.RetrieveDatasetFreshness(ctx)\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.aml().retrieveDatasetFreshness();
            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->aml->retrieveDatasetFreshness();
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.aml.retrieve_dataset_freshness
            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.Aml.RetrieveDatasetFreshnessAsync();
            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    AMLDatasetFreshness:
      type: object
      description: >-
        Degré de fraîcheur des jeux de données AML lors de l'exécution d'un
        filtrage. Les dates ne sont jamais estimées.
      required:
        - captured_at
        - provider
        - catalog_version
        - sources
      properties:
        captured_at:
          type: string
          format: date-time
          description: >-
            Date et heure auxquelles Didit a lu le catalogue de jeux de données
            dont provient cette fraîcheur.
        provider:
          type: string
          description: "Identifiant opaque de la source de données AML. Traitez-le comme une chaîne opaque\_; ne créez pas de branche conditionnelle dessus."
          example: aml_data_source
        catalog_version:
          type: string
          nullable: true
          description: >-
            Identifiant de version du catalogue de jeux de données, lorsque la
            source en transmet un.
        sources:
          type: object
          description: >-
            Fraîcheur par famille de jeux de données. Une famille dont les jeux
            de données n'ont signalé aucune date de mise à jour est absente
            plutôt que renseignée avec `null`.
          properties:
            sanctions:
              $ref: '#/components/schemas/AMLDatasetSourceFreshness'
            pep:
              $ref: '#/components/schemas/AMLDatasetSourceFreshness'
            warnings:
              $ref: '#/components/schemas/AMLDatasetSourceFreshness'
            adverse_media:
              $ref: '#/components/schemas/AMLDatasetSourceFreshness'
    AMLDatasetSourceFreshness:
      type: object
      description: Fraîcheur d'une famille de jeux de données AML.
      required:
        - last_updated_at
        - oldest_updated_at
        - dataset_count
        - dated_dataset_count
      properties:
        last_updated_at:
          type: string
          format: date-time
          description: >-
            Mise à jour la plus récente de n'importe quel jeu de données de la
            famille.
        oldest_updated_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            Limite d'obsolescence : chaque jeu de données de la famille est au
            moins aussi récent. `null` lorsqu'au moins un jeu de données de la
            famille n'a indiqué aucune date de mise à jour, car la limite est
            alors inconnue.
        dataset_count:
          type: integer
          description: Nombre de jeux de données dans la famille.
        dated_dataset_count:
          type: integer
          description: Nombre de ces jeux de données ayant signalé une date de mise à jour.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.

````

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