> ## 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 Travel Rule: listar pruebas de wallet por captura

> Lista con la API de Didit las pruebas de propiedad de wallet por captura pendientes de revisión, primero las más antiguas, con imagen y transacción.

Prompt de la API para listar pruebas de wallet
Copiar el prompt al portapapeles

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

Pegar en


## OpenAPI

````yaml es/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 verificación de identidad. Autentícate con el encabezado x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-proofs/:
    get:
      tags:
        - Travel Rule
      summary: >-
        Listar las pruebas de wallet por captura de pantalla pendientes de
        revisión
      description: >-
        Tu cola de revisión de pruebas de propiedad de wallet mediante captura
        de pantalla. Una captura de pantalla es la única prueba que Didit no
        puede comprobar por sí mismo: una vez que el usuario final la sube desde
        el widget, queda en PENDING hasta que la apruebes o la rechaces con POST
        /v3/travel-rule/wallet-proofs/{proof_uuid}/decision/. Las más antiguas
        primero, de modo que la cola se procesa a partir de la prueba que lleva
        más tiempo esperando. Solo aparecen las capturas de pantalla subidas,
        nunca una prueba cuyo usuario final aún no ha subido un archivo, ni una
        de una wallet que eliminaste de tu libreta de direcciones (Didit las
        cierra como OWNERSHIP_CHANGED).
      operationId: listTravelRuleWalletProofs
      parameters:
        - name: status
          in: query
          description: >-
            Qué pruebas listar. El valor predeterminado es PENDING, las que aún
            están por decidir.
          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: >-
            Capturas de pantalla de prueba paginadas. count es exacto hasta 100
            y, por encima, se limita a 100.
          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: Estado desconocido.
        '401':
          description: x-api-key ausente o no válido.
        '403':
          description: Quien hace la llamada no tiene el permiso de transacciones.
      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: Identificador canónico de la cadena, p. ej., ETH, BTC, SOL, TRX.
        holder_name:
          type: string
        is_ownership_verified:
          type: boolean
          description: >-
            Si la entrada de la libreta de direcciones tiene la propiedad
            verificada, mediante esta prueba u otra.
        transaction_id:
          type: string
          format: uuid
          nullable: true
          description: >-
            La transacción para cuya transferencia de Travel Rule se creó la
            sesión del widget. Es null para una sesión creada sin
            transaction_id.
        file_name:
          type: string
          nullable: true
        content_type:
          type: string
          nullable: true
        screenshot_url:
          type: string
          nullable: true
          description: >-
            Enlace de validez limitada a la captura de pantalla subida. Vuelve a
            listar la cola para obtener un enlace nuevo.
        attempts:
          type: integer
          description: Cuántos archivos subió el usuario final para esta prueba.
        failure_reason:
          allOf:
            - $ref: '#/components/schemas/TravelRuleWalletProofFailureReason'
          description: >-
            REVIEW_REJECTED tras un rechazo, OWNERSHIP_CHANGED cuando la wallet
            cambió de titular o se eliminó antes de una decisión. Vacío en caso
            contrario.
        method_chosen_at:
          type: string
          format: date-time
          nullable: true
          description: Cuándo el usuario final eligió el método de captura de pantalla.
        decided_at:
          type: string
          format: date-time
          nullable: true
        decided_by:
          type: string
          description: >-
            Quién cerró la prueba: review:<user identifier> para un revisor de
            la consola, review para una decisión tomada con una clave de API,
            widget o sweeper cuando Didit la cerró automáticamente. Vacío
            mientras está en PENDING.
        review_note:
          type: string
          description: La nota enviada con la decisión. Vacía cuando no hay ninguna.
        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: >-
        Por qué una prueba de propiedad de wallet, o su último intento, no llegó
        a VERIFIED. Vacío cuando nada falló. Una prueba PENDING puede tener uno:
        el último intento falló y el usuario final puede volver a intentarlo.
        DEPOSIT_MISMATCH, DEPOSIT_STALE, TXID_REUSED y REVIEW_REJECTED cierran
        la prueba como REJECTED. SIGNATURE_INVALID: la firma no coincide con la
        wallet y el desafío. SIGNATURE_UNSUPPORTED_SCHEME: la wallet firmó en un
        formato que Didit no verifica. DEPOSIT_NOT_FOUND, DEPOSIT_UNCONFIRMED,
        DEPOSIT_LOOKUP_FAILED: el depósito de prueba no se puede leer o aún no
        está confirmado; Didit sigue comprobándolo hasta que se cierra la
        ventana de prueba. DEPOSIT_MISMATCH: la transacción no envía el importe
        esperado desde la wallet a la dirección de depósito. DEPOSIT_STALE: la
        transacción es anterior al desafío. TXID_REUSED: la transacción ya
        sirvió como prueba de otra wallet. CHAIN_UNSUPPORTED: el método no está
        disponible en esta cadena. WINDOW_EXPIRED: se cerró la ventana de
        prueba. OWNERSHIP_CHANGED: el titular de la wallet cambió, o la wallet
        se eliminó de tu libreta de direcciones, después de que se generara la
        sesión del widget. METHOD_SWITCHED: el usuario final eligió otro método
        antes de terminar este. REVIEW_REJECTED: tu revisor rechazó la captura
        de pantalla. ABANDONED: la sesión del widget caducó antes de que el
        usuario final terminara.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clave de API de tu aplicación, que encontrarás en Developers -> API
        keys en la Business Console. La clave principal tiene acceso completo.
        Una clave con nombre puede tener un alcance limitado: ninguno, lectura o
        escritura por recurso, limitada a algunos flujos o a sesiones aprobadas,
        a una lista de direcciones IP y a una fecha de caducidad. 401 significa
        que la clave es incorrecta, se revocó o expiró; 403 significa que no se
        envió ninguna clave, que la clave no tiene acceso a este recurso o
        acción, o que la solicitud provino de una dirección fuera de su lista de
        IP; 404 en una ruta de sesión significa que la sesión está fuera de los
        flujos o estados de la clave. Una clave sin acceso a contenido
        multimedia recibe las URL de imágenes, videos y PDF como null, y una
        clave sin permiso de escritura en sesiones recibe los enlaces y tokens
        de sesión como null. Consulta https://docs.didit.me/console/api-keys.

````

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