> ## 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 liste des preuves de portefeuille - Travel Rule

> Didit : listez les preuves de propriété de portefeuille par capture d'écran en attente d'examen, de la plus ancienne à la plus récente.

Prompt de l'API List Wallet Proofs
Copier le prompt dans le presse-papiers

<pre>
  \`List the screenshot wallet-ownership proofs my end users uploaded from the wallet-ownership widget, so my compliance team can review them.

  Endpoint:
  GET [https://verification.didit.me/v3/travel-rule/wallet-proofs/](https://verification.didit.me/v3/travel-rule/wallet-proofs/)

  Authentication:
  Use the x-api-key header with my Didit API key.

  Query parameters:

  * status - PENDING (default, the proofs still to decide), VERIFIED, REJECTED or EXPIRED.
  * limit, offset - pagination.

  What to read from each result:

  * proof\_id - pass it to POST /v3/travel-rule/wallet-proofs/{proof_uuid}/decision/ to approve or reject.
  * screenshot\_url - time-limited link to the uploaded image; list again for a fresh link.
  * wallet\_address, chain (canonical, e.g. ETH, BTC, SOL, TRX), holder\_name, is\_ownership\_verified.
  * transaction\_id - the transaction the widget session was minted for, null when none.
  * attempts, failure\_reason, method\_chosen\_at, decided\_at, decided\_by, review\_note.

  Behavior:

  * Oldest first, so the proof that has waited longest comes first.
  * Only uploaded screenshots appear. A proof on a wallet I deleted from my address book never appears: Didit closes it as OWNERSHIP\_CHANGED.

  Failure modes:

  * 400 - unknown status.
  * 401 - missing or malformed x-api-key.

  Full guide: /transaction-monitoring/wallet-ownership-widget#what-it-proves.\`
</pre>

Coller dans


## OpenAPI

````yaml fr/openapi-25.json GET /v3/travel-rule/wallet-proofs/
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/travel-rule/wallet-proofs/:
    get:
      tags:
        - Travel Rule
      summary: Lister les preuves de portefeuille par capture d'écran à examiner
      description: >-
        Votre file d'attente d'examen des preuves de propriété de portefeuille
        par capture d'écran. Une capture d'écran est la seule preuve que Didit
        ne peut pas vérifier lui-même : dès que l'utilisateur final la téléverse
        depuis le widget, elle reste PENDING jusqu'à ce que vous l'approuviez ou
        la rejetiez via POST
        /v3/travel-rule/wallet-proofs/{proof_uuid}/decision/. Les plus anciennes
        en premier, afin de traiter la file d'attente à partir de la preuve qui
        attend depuis le plus longtemps. Seules les captures d'écran téléversées
        apparaissent, jamais une preuve pour laquelle l'utilisateur final n'a
        pas encore téléversé de fichier, ni une preuve associée à un
        portefeuille que vous avez supprimé de votre carnet d'adresses (Didit
        clôture ces dernières avec l'état OWNERSHIP_CHANGED).
      operationId: listTravelRuleWalletProofs
      parameters:
        - name: status
          in: query
          description: >-
            Quelles preuves lister. Vaut par défaut PENDING, celles qui restent
            à trancher.
          schema:
            type: string
            enum:
              - PENDING
              - VERIFIED
              - REJECTED
              - EXPIRED
            default: PENDING
        - name: limit
          in: query
          schema:
            type: integer
            default: 50
            minimum: 1
        - name: offset
          in: query
          schema:
            type: integer
            default: 0
            minimum: 0
      responses:
        '200':
          description: >-
            Preuves par capture d'écran paginées. Le décompte est exact jusqu'à
            100 et plafonné à 100 au-delà.
          content:
            application/json:
              schema:
                type: object
                properties:
                  count:
                    type: integer
                  next:
                    type: string
                    nullable: true
                  previous:
                    type: string
                    nullable: true
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/TravelRuleWalletProofReview'
        '400':
          description: Statut inconnu.
        '401':
          description: x-api-key manquant ou invalide.
        '403':
          description: >-
            L'appelant ne dispose pas de l'autorisation requise pour les
            transactions.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl
            https://verification.didit.me/v3/travel-rule/wallet-proofs/?status=PENDING
            \
              -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.travel_rule.wallet_proofs.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.travelRule.walletProofs.list()) {
              console.log(item);
            }
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

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

            for (var item : client.travelRule().walletProofs().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->travelRule->walletProofs->list() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            didit.travel_rule.wallet_proofs.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.TravelRule.WalletProofs.ListAsync())

            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    TravelRuleWalletProofReview:
      type: object
      properties:
        proof_id:
          type: string
          format: uuid
        method:
          type: string
          enum:
            - SCREENSHOT
        status:
          type: string
          enum:
            - PENDING
            - VERIFIED
            - REJECTED
            - EXPIRED
        wallet_address:
          type: string
        chain:
          type: string
          description: Identifiant canonique de la blockchain, par ex. ETH, BTC, SOL, TRX.
        holder_name:
          type: string
        is_ownership_verified:
          type: boolean
          description: >-
            Indique si l'entrée du carnet d'adresses a fait l'objet d'une
            vérification de propriété, par cette preuve ou par une autre.
        transaction_id:
          type: string
          format: uuid
          nullable: true
          description: >-
            La transaction associée au transfert Travel Rule pour lequel la
            session de widget a été créée. Null pour une session créée sans
            transaction_id.
        file_name:
          type: string
          nullable: true
        content_type:
          type: string
          nullable: true
        screenshot_url:
          type: string
          nullable: true
          description: >-
            Lien temporaire vers la capture d'écran téléchargée. Listez à
            nouveau la file d'attente pour obtenir un lien actualisé.
        attempts:
          type: integer
          description: >-
            Nombre de fichiers que l'utilisateur final a téléchargés pour ce
            justificatif.
        failure_reason:
          allOf:
            - $ref: '#/components/schemas/TravelRuleWalletProofFailureReason'
          description: >-
            REVIEW_REJECTED après un refus, OWNERSHIP_CHANGED lorsque le
            portefeuille a changé de titulaire ou a été supprimé avant une
            décision. Vide dans les autres cas.
        method_chosen_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            Date et heure auxquelles l'utilisateur final a choisi la méthode par
            capture d'écran.
        decided_at:
          type: string
          format: date-time
          nullable: true
        decided_by:
          type: string
          description: >-
            Qui a clôturé la preuve : review:<user identifier> pour un réviseur
            de la console, review pour une décision prise par clé API, widget ou
            sweeper lorsque Didit l'a clôturée automatiquement. Vide tant que le
            statut est PENDING.
        review_note:
          type: string
          description: La note envoyée avec la décision. Vide s'il n'y en a aucune.
        created_at:
          type: string
          format: date-time
    TravelRuleWalletProofFailureReason:
      type: string
      enum:
        - ''
        - SIGNATURE_INVALID
        - SIGNATURE_UNSUPPORTED_SCHEME
        - DEPOSIT_NOT_FOUND
        - DEPOSIT_UNCONFIRMED
        - DEPOSIT_LOOKUP_FAILED
        - DEPOSIT_MISMATCH
        - DEPOSIT_STALE
        - TXID_REUSED
        - CHAIN_UNSUPPORTED
        - WINDOW_EXPIRED
        - OWNERSHIP_CHANGED
        - METHOD_SWITCHED
        - REVIEW_REJECTED
        - ABANDONED
      description: "Raison pour laquelle une preuve de propriété du portefeuille, ou sa dernière tentative, n'a pas atteint le statut VERIFIED. Vide lorsque rien n'a échoué. Une preuve PENDING peut en comporter une\_: la dernière tentative a échoué et l'utilisateur final peut réessayer. DEPOSIT_MISMATCH, DEPOSIT_STALE, TXID_REUSED et REVIEW_REJECTED clôturent la preuve comme REJECTED. SIGNATURE_INVALID\_: la signature ne correspond pas au portefeuille et au défi. SIGNATURE_UNSUPPORTED_SCHEME\_: le portefeuille a signé dans un format que Didit ne vérifie pas. DEPOSIT_NOT_FOUND, DEPOSIT_UNCONFIRMED, DEPOSIT_LOOKUP_FAILED\_: le dépôt test n'est pas lisible ou pas encore confirmé\_; Didit continue de vérifier jusqu'à la fermeture de la fenêtre de test. DEPOSIT_MISMATCH\_: la transaction n'envoie pas le montant attendu depuis le portefeuille vers l'adresse de dépôt. DEPOSIT_STALE\_: la transaction est antérieure au défi. TXID_REUSED\_: la transaction a déjà servi à prouver un autre portefeuille. CHAIN_UNSUPPORTED\_: la méthode n'est pas disponible sur cette blockchain. WINDOW_EXPIRED\_: la fenêtre de test a expiré. OWNERSHIP_CHANGED\_: le détenteur du portefeuille a changé, ou le portefeuille a été supprimé de votre carnet d'adresses après la création de la session de widget. METHOD_SWITCHED\_: l'utilisateur final a choisi une autre méthode avant de terminer celle-ci. REVIEW_REJECTED\_: votre réviseur a rejeté la capture d'écran. ABANDONED\_: la session de widget a expiré avant que l'utilisateur final n'ait terminé."
  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.