> ## 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 Lister les listes de blocage et d'autorisation

> GET /v3/lists/ : récupérez les listes de blocage, d'autorisation et personnalisées de Didit. Filtrage par type. Paiement à l'appel, sans contrat.



Prompt pour l'API List Lists
        Copier le prompt dans le presse-papiers



      
      

\<pre>

\`Retrieve every blocklist, allowlist, and custom list in my Didit application through the Management API.

Endpoint:
GET https://verification.didit.me/v3/lists/

Authentication:
Use the x-api-key header with my Didit API key. A scoped API key needs workflows: read.

Goal:
\- Get a paginated list of all lists for my application so I can find a specific list's uuid, filter by type, or render a picker.

Behavior:
\- Returns the application's active lists, newest first by default. Deleted lists never appear.
\- Includes the system lists Didit provisions (is_system: true): one blocklist per entry type, the "High Risk Countries" custom list, and any system allowlist.
\- Paginated with limit (default 50) and offset. Follow next until it is null.

Query parameters (all optional):
\- list_type: "blocklist" | "allowlist" | "custom".
\- entry_type: face, document, phone, email, ip_address, device_fingerprint, wallet_address, bank_account, country, user, business, key.
\- ordering: created_at or -created_at (default).
\- limit: page size (default 50, at most 1000000).
\- offset: pagination offset (default 0).

Example call:
curl -X GET "https://verification.didit.me/v3/lists/?list_type=blocklist" \
-H "x-api-key: YOUR_API_KEY"

What to read from the response:
\- count / next / previous: standard pagination envelope.
\- results[].uuid: list id; use it as list_uuid in the list and entry calls.
\- results[].is_system: true for the lists Didit provisions. System lists cannot be renamed, edited or deleted, but you can add and remove their entries.
\- results[].entry_count, last_entry_added_at: computed over the list's current entries; useful for dashboards.

Failure modes:
\- 400: an unknown list_type or entry_type value, or limit/offset above 1000000.
\- 401: the API key has expired.
\- 403: missing x-api-key (a wrong, revoked or expired key gets 401) ({ "detail": "You do not have permission to perform this action." }), or a scoped key without workflows: read.
\- 429: rate limited (see /integration/rate-limiting); back off and retry.

Side effects: none. This is a pure read.

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

\</pre>



      
      

Coller dans

Récupérez une liste paginée de toutes les listes actives de votre application : les listes système que Didit provisionne (une liste de blocage par type d'entrée, la liste **High Risk Countries** et toute liste d'autorisation système), ainsi que les listes d'autorisation et les listes personnalisées que vous avez créées. Filtrez par `list_type` ou `entry_type`, et lisez les valeurs d'une liste avec [Entrées de liste](https://docs.didit.me/fr/management-api/lists/list-entries.md).Consultez [Listes](https://docs.didit.me/fr/management-api/lists/overview.md) pour savoir ce que fait chaque type de liste pendant la vérification et le filtrage des transactions.


## OpenAPI

````yaml fr/openapi-25.json GET /v3/lists/
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/lists/:
    get:
      tags:
        - Lists
      summary: Lister les listes
      description: >-
        Renvoie les listes de l'application, les plus récentes en premier : les
        listes système fournies par Didit (une liste de blocage par type
        d'entrée, la liste personnalisée **High Risk Countries** et toute liste
        d'autorisation système) ainsi que les listes d'autorisation et listes
        personnalisées que vous avez créées. Filtrez avec `list_type` et
        `entry_type` ; les listes supprimées n'apparaissent jamais. Les
        résultats sont paginés avec `limit` et `offset`. Une clé API restreinte
        nécessite `workflows: read`. Consultez
        [Listes](https://docs.didit.me/fr/management-api/lists/overview) pour
        connaître le rôle de chaque type de liste.
      operationId: list_lists
      parameters:
        - name: list_type
          in: query
          required: false
          description: Uniquement les listes de ce type.
          schema:
            type: string
            enum:
              - blocklist
              - allowlist
              - custom
        - name: entry_type
          in: query
          required: false
          description: Uniquement les listes de ce type d'entrée.
          schema:
            type: string
            enum:
              - face
              - document
              - phone
              - email
              - ip_address
              - device_fingerprint
              - wallet_address
              - bank_account
              - country
              - user
              - business
              - key
        - name: ordering
          in: query
          required: false
          description: >-
            Ordre de tri : `-created_at` (le plus récent en premier, par défaut)
            ou `created_at` (le plus ancien en premier).
          schema:
            type: string
            enum:
              - '-created_at'
              - created_at
            default: '-created_at'
        - name: limit
          in: query
          required: false
          description: "Taille de page. Vaut 50 par défaut. Une valeur supérieure à 1000000 renvoie `400`\_; une valeur égale à zéro, négative ou non numérique repasse par défaut à 50."
          schema:
            type: integer
            default: 50
            minimum: 1
            maximum: 1000000
        - name: offset
          in: query
          required: false
          description: >-
            Indice de départ (base zéro) du premier élément à retourner.
            Privilégiez l'utilisation de `next`. Une valeur supérieure à 1000000
            retourne `400` ; une valeur négative ou non numérique revient par
            défaut à 0.
          schema:
            type: integer
            maximum: 1000000
            minimum: 0
            default: 0
      responses:
        '200':
          description: Une page de listes.
          content:
            application/json:
              schema:
                type: object
                required:
                  - count
                  - next
                  - previous
                  - results
                properties:
                  count:
                    type: integer
                    minimum: 0
                    description: Nombre total de listes correspondant aux filtres.
                  next:
                    type: string
                    format: uri
                    nullable: true
                    description: >-
                      URL absolue de la page suivante, ou `null` sur la dernière
                      page.
                  previous:
                    type: string
                    format: uri
                    nullable: true
                    description: >-
                      URL absolue de la page précédente, ou `null` sur la
                      première page.
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/ComplianceList'
              examples:
                Lists:
                  value:
                    count: 2
                    next: null
                    previous: null
                    results:
                      - uuid: 22222222-3333-4444-5555-666666666666
                        name: Trusted office IPs
                        description: Office egress ranges
                        list_type: allowlist
                        entry_type: ip_address
                        is_system: false
                        entry_count: 3
                        last_entry_added_at: '2026-10-02T08:15:27.501334Z'
                        created_at: '2026-09-30T13:20:45.889120Z'
                        updated_at: '2026-09-30T13:20:45.889120Z'
                      - uuid: 11111111-2222-3333-4444-555555555555
                        name: Face Blocklist
                        description: >-
                          Blocked biometric faces. When a face matching an entry
                          in this list is detected during liveness verification,
                          the session will be automatically declined.
                        list_type: blocklist
                        entry_type: face
                        is_system: true
                        entry_count: 12
                        last_entry_added_at: '2026-10-09T16:42:03.118204Z'
                        created_at: '2026-01-14T10:02:11.402917Z'
                        updated_at: '2026-01-14T10:02:11.402917Z'
        '400':
          description: Un paramètre de requête est invalide.
          content:
            application/json:
              examples:
                Unknown list type:
                  value:
                    list_type:
                      - '"denylist" is not a valid choice.'
                Unsupported ordering:
                  value:
                    ordering:
                      - '"name" is not a valid choice.'
                Limit too large:
                  value:
                    - limit must not exceed 1000000.
        '401':
          description: >-
            La clé API restreinte a expiré. Les autres échecs d'authentification
            renvoient `403`.
          content:
            application/json:
              examples:
                Expired API key:
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            L'en-tête `x-api-key` est manquant (une clé incorrecte, révoquée ou
            expirée renvoie `401`), ou une clé API restreinte n'a pas
            l'autorisation `workflows: read` ou est utilisée depuis une adresse
            IP hors de sa liste d'autorisation.
          content:
            application/json:
              examples:
                Missing or invalid API key:
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without workflows access:
                  value:
                    detail: This API key has no read access to workflows.
        '429':
          description: >-
            La limite de lecture partagée de 600 requêtes par minute et par clé
            API a été dépassée. Respectez l'en-tête `Retry-After` avant de
            réessayer.
          content:
            application/json:
              examples:
                Rate limited:
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/lists/?list_type=blocklist' \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            for item in client.lists.list():
                print(item)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            for await (const item of didit.lists.list()) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.Lists.ListAutoPaging(ctx, didit.ListsListParams{})\nfor iter.Next() {\n\tfmt.Printf(\"%+v\\n\", iter.Current())\n}\nif err := iter.Err(); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            for (var item : client.lists().list()) {
                System.out.println(item);
            }
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            foreach ($didit->lists->list() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            didit.lists.list.auto_paging_each do |item|
              puts item.to_h
            end
        - lang: csharp
          label: .NET
          source: |-
            using System;
            using System.Text.Json;
            using Didit;

            // Reads DIDIT_API_KEY.
            using var client = new DiditClient();

            await foreach (var item in await client.Lists.ListAsync())
            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    ComplianceList:
      type: object
      description: >-
        Une liste de blocage, une liste d'autorisation ou une liste
        personnalisée d'une application.
      required:
        - uuid
        - name
        - description
        - list_type
        - entry_type
        - is_system
        - entry_count
        - last_entry_added_at
        - created_at
        - updated_at
      properties:
        uuid:
          type: string
          format: uuid
          description: >-
            Identifiant de liste. Utilisez-le comme `list_uuid` dans les
            endpoints de liste et d'entrée, et comme valeur d'une condition de
            règle de workflow ou de transaction avec `value_type: "list"`.
        name:
          type: string
          maxLength: 255
          description: Nom de la liste, unique parmi les listes de l'application.
        description:
          type: string
          description: >-
            Description en texte libre. Chaîne vide lorsqu'elle n'est pas
            définie.
        list_type:
          type: string
          enum:
            - blocklist
            - allowlist
            - custom
          description: >-
            `blocklist` : une correspondance refuse la session ou la transaction
            (listes système uniquement, une par type d'entrée). `allowlist` :
            les éléments correspondants sont considérés comme fiables, par
            exemple une liste d'autorisation de visages ignore l'action de
            visage dupliqué ; ne prévaut jamais sur une correspondance de liste
            de blocage. `custom` : utilisé dans les conditions de règles de
            transaction et de workflow (`value_type: "list"`).
        entry_type:
          type: string
          enum:
            - face
            - document
            - phone
            - email
            - ip_address
            - device_fingerprint
            - wallet_address
            - bank_account
            - country
            - user
            - business
            - key
          description: "Ce que contient la liste\_: `face`, `document` (numéro de document), `phone`, `email`, `ip_address` (adresse ou plage CIDR), `device_fingerprint`, `wallet_address`, `bank_account`, `country` (ISO 3166-1 alpha-3), `user` ou `business` (vos `vendor_data`), ou `key` (toute chaîne). Cela détermine la manière dont les valeurs des entrées sont validées et mises en correspondance."
        is_system:
          type: boolean
          description: >-
            `true` pour les listes configurées par Didit : une liste de blocage
            par type d'entrée (`face`, `document`, `phone`, `email`,
            `ip_address`, `device_fingerprint`, `wallet_address`,
            `bank_account`, `user`, `business`), la liste personnalisée **High
            Risk Countries** et les listes d'autorisation du système. Les listes
            système ne peuvent être ni renommées, ni modifiées, ni supprimées ;
            vous pouvez ajouter et supprimer leurs entrées.
        entry_count:
          type: integer
          minimum: 0
          description: Nombre d'entrées actuellement dans la liste.
        last_entry_added_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            Moment où l'entrée actuelle la plus récente a été ajoutée. `null`
            pour une liste vide.
        created_at:
          type: string
          format: date-time
          description: Moment où la liste a été créée.
        updated_at:
          type: string
          format: date-time
          description: Moment où la liste a été mise à jour pour la dernière fois.
  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.