> ## 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 liste de blocage : lister les éléments bloqués

> GET /v3/blocklist/ : liste les visages, documents, téléphones et e-mails bloqués de vos sessions Didit, du plus récent au plus ancien.



Prompt API pour lister les éléments de la liste de blocage
        Copier le prompt dans le presse-papiers



      
      

\<pre>

\`List the blocklisted faces, documents, phone numbers and email addresses of my Didit verification sessions through the Management API.

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

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

Goal:
\- Get one paginated feed of every session record that is currently blocklisted, to build a "Blocked" screen or audit what my team has blocked.

Behavior:
\- Items are sorted by blocklisted_at, newest first. Items of deleted sessions are not included.
\- Each item has a type ("face", "document", "phone" or "email") and the session it belongs to (session_id, session_number). Fields that do not apply to the type are null.
\- The feed covers records blocklisted from a session: with POST /v3/blocklist/add/, from the console, or with a list entry created from reference_session_id. It does not include values added to a list by hand, uploaded faces, faces taken from a document-capture selfie, or IP address, device fingerprint, wallet, bank account, user and business entries. Read those with GET /v3/lists/{list_uuid}/entries/ on the matching system blocklist.
\- face_image and front_image are short-lived signed URLs, issued again on every call; a scoped key without media: read gets null instead.

Query parameters (all optional):
\- item_type: "face" | "document" | "phone" | "email". When omitted, every type is returned.
\- limit: page size (default 50, at most 1000000).
\- offset: pagination offset (default 0).

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

What to read from the response:
\- count / next / previous: standard pagination envelope.
\- results[].type, session_id, session_number, blocklisted_at.
\- face items: face_image.
\- document items: document_type (for example "P" passport, "ID" national ID, "DL" driver's license), document_number, front_image.
\- phone items: phone_number (E.164), country_code (ISO 3166-1 alpha-2).
\- email items: email.

Failure modes:
\- 400: an unknown item_type, 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

Listez les visages, documents d'identité, numéros de téléphone et adresses e-mail de vos sessions de vérification actuellement placés sur la liste de blocage, du plus récent au plus ancien. Chaque élément renvoie à la session dont il provient, afin que vous puissiez l'ouvrir dans la console ou récupérer sa décision.Ce flux affiche les éléments mis en liste de blocage **depuis une session** : avec [Ajouter à la liste de blocage](https://docs.didit.me/fr/management-api/blocklist/add.md), depuis la console, ou avec une [entrée de liste](https://docs.didit.me/fr/management-api/lists/create-entry.md) créée à partir de `reference_session_id`. Les valeurs saisies dans une liste, les [visages téléversés](https://docs.didit.me/fr/management-api/lists/upload-face.md), les visages extraits d'un selfie de capture de document et les autres types d'entrées (adresse IP, empreinte de l'appareil, portefeuille, compte bancaire, utilisateur, entreprise) ne figurent que dans les listes de blocage du système : consultez-les avec [Entrées de liste](https://docs.didit.me/fr/management-api/lists/list-entries.md).Voir [Blocage des utilisateurs](https://docs.didit.me/fr/console/blocklist-users.md) pour savoir comment fonctionne la mise en liste de blocage dans la console.


## OpenAPI

````yaml fr/openapi-25.json GET /v3/blocklist/
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/blocklist/:
    get:
      tags:
        - Blocklist
      summary: Lister les éléments de la liste de blocage
      description: "Renvoie un flux paginé des visages, documents d'identité, numéros de téléphone et adresses e-mail des sessions de vérification de l'application qui sont actuellement sur liste de blocage, le `blocklisted_at` le plus récent en premier\_; filtrez avec `item_type`. Les éléments des sessions supprimées ne sont pas inclus. Le flux couvre les enregistrements placés sur liste de blocage à partir d'une session (avec [Ajouter des éléments de session à la liste de blocage](https://docs.didit.me/fr/management-api/blocklist/add), depuis la console ou par une entrée de liste créée à partir d'une session)\_; les valeurs ajoutées manuellement à une liste, les visages téléversés, les visages issus d'un selfie de capture de document et les autres types d'entrées sont lus avec [Répertorier les entrées de liste](https://docs.didit.me/fr/management-api/lists/list-entries). `face_image` et `front_image` sont des URL signées à courte durée de vie, et une clé API restreinte sans `media: read` reçoit `null`. Une clé API restreinte nécessite `workflows: read`."
      operationId: list_blocklist_items
      parameters:
        - name: item_type
          in: query
          required: false
          description: >-
            Uniquement les éléments de ce type. Lorsqu'il est omis, tous les
            types sont renvoyés.
          schema:
            type: string
            enum:
              - face
              - document
              - phone
              - email
        - 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 d'éléments sur liste de blocage, les plus récents en
            premier.
          content:
            application/json:
              schema:
                type: object
                required:
                  - count
                  - next
                  - previous
                  - results
                properties:
                  count:
                    type: integer
                    minimum: 0
                    description: >-
                      Nombre total d'éléments de liste de blocage 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/BlocklistedItem'
              examples:
                Mixed feed:
                  value:
                    count: 2
                    next: null
                    previous: null
                    results:
                      - type: document
                        session_id: 33333333-4444-5555-6666-777777777777
                        session_number: 1042
                        blocklisted_at: '2026-10-12T10:06:12.701553Z'
                        face_image: null
                        document_type: ID
                        document_number: X1234567
                        front_image: >-
                          https://media.example.com/documents/front.jpg?expires=1760263938&signature=8b2e47
                        phone_number: null
                        country_code: null
                        email: null
                      - type: phone
                        session_id: 77777777-8888-9999-0000-111111111111
                        session_number: 1017
                        blocklisted_at: '2026-10-08T15:31:09.400127Z'
                        face_image: null
                        document_type: null
                        document_number: null
                        front_image: null
                        phone_number: '+14155552671'
                        country_code: US
                        email: null
        '400':
          description: Un paramètre de requête est invalide.
          content:
            application/json:
              examples:
                Unknown item type:
                  value:
                    item_type:
                      - '"wallet" 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/blocklist/?item_type=document' \
              -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.blocklist.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.blocklist.list()) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.Blocklist.ListAutoPaging(ctx, didit.BlocklistListParams{})\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.blocklist().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->blocklist->list() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            didit.blocklist.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.Blocklist.ListAsync())
            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    BlocklistedItem:
      type: object
      description: >-
        Un visage, un document d'identité, un numéro de téléphone ou une adresse
        e-mail sur liste de blocage provenant d'une session de vérification. Les
        champs qui ne s'appliquent pas au `type` de l'élément sont `null`.
      required:
        - type
        - session_id
        - session_number
        - blocklisted_at
        - face_image
        - document_type
        - document_number
        - front_image
        - phone_number
        - country_code
        - email
      properties:
        type:
          type: string
          enum:
            - face
            - document
            - phone
            - email
          description: Ce qui a été ajouté à la liste de blocage.
        session_id:
          type: string
          format: uuid
          description: Session de vérification à laquelle appartient l'élément.
        session_number:
          type: integer
          nullable: true
          description: >-
            Numéro de cette session propre à l'application, tel qu'affiché dans
            la console.
        blocklisted_at:
          type: string
          format: date-time
          description: >-
            Moment où l'élément a été ajouté à la liste de blocage pour la
            dernière fois.
        face_image:
          type: string
          nullable: true
          description: >-
            Éléments faciaux : URL signée à courte durée de vie, réémise à
            chaque appel ; `null` pour une clé API restreinte sans `media:
            read`. Également `null` lorsqu'aucune image de référence n'est
            stockée.
        document_type:
          type: string
          nullable: true
          description: >-
            Éléments de document : code du type de document, par exemple `P`
            (passeport), `ID` (carte nationale d'identité), `DL` (permis de
            conduire) ou `RP` (titre de séjour).
        document_number:
          type: string
          nullable: true
          description: >-
            Éléments de document : numéro du document, ou numéro personnel
            lorsque le document n'en comporte pas.
        front_image:
          type: string
          nullable: true
          description: >-
            Éléments de document : image du recto du document, URL signée de
            courte durée, réémise à chaque appel ; `null` pour une clé API
            restreinte sans `media: read`.
        phone_number:
          type: string
          nullable: true
          description: 'Éléments téléphoniques : le numéro de téléphone au format E.164.'
        country_code:
          type: string
          nullable: true
          description: 'Éléments téléphoniques : pays ISO 3166-1 alpha-2 du numéro.'
        email:
          type: string
          nullable: true
          description: 'Éléments de l''e-mail : l''adresse e-mail.'
  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.