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

# Travel Rule: llista de proves de cartera per revisar

> Llista amb Didit les proves de cartera en captura de pantalla pendents de revisió, de la més antiga a la més nova, amb imatge i transacció.

Prompt de l'API per llistar proves de cartera
Copia el prompt al porta-retalls

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

Enganxa a


## OpenAPI

````yaml ca/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ó d'identitat. Autentica't amb la capçalera x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/travel-rule/wallet-proofs/:
    get:
      tags:
        - Travel Rule
      summary: >-
        Llista les proves de cartera amb captures de pantalla pendents de
        revisió
      description: >-
        La teva cua de revisió de captures de pantalla com a comprovants de
        titularitat de la cartera. Una captura de pantalla és l'únic comprovant
        que Didit no pot comprovar per si mateix: un cop l'usuari final la puja
        des del widget, roman en PENDING fins que l'aprovis o la rebutgis amb
        POST /v3/travel-rule/wallet-proofs/{proof_uuid}/decision/. Primer les
        més antigues, de manera que la cua es processa començant pel comprovant
        que fa més temps que espera. Només apareixen les captures de pantalla
        pujades, mai cap comprovant on l'usuari final encara no hagi pujat cap
        fitxer, i mai cap en una cartera que hagis eliminat de la teva llibreta
        d'adreces (Didit les tanca com a OWNERSHIP_CHANGED).
      operationId: listTravelRuleWalletProofs
      parameters:
        - name: status
          in: query
          description: >-
            Quines proves s'han de llistar. Per defecte és PENDING, les que
            encara s'han de 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: >-
            Proves amb captures de pantalla paginades. El recompte és exacte
            fins a 100 i es limita a 100 per sobre d'aquest valor.
          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: Estat desconegut.
        '401':
          description: Falta l'x-api-key o no és vàlid.
        '403':
          description: L'emissor de la crida no té el permís de transaccions.
      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ònic de la cadena, p. ex. ETH, BTC, SOL, TRX.
        holder_name:
          type: string
        is_ownership_verified:
          type: boolean
          description: >-
            Indica si l'entrada de la llibreta d'adreces té la titularitat
            verificada, mitjançant aquesta prova o una altra.
        transaction_id:
          type: string
          format: uuid
          nullable: true
          description: >-
            La transacció per a la transferència de Travel Rule de la qual es va
            generar la sessió del widget. Null per a una sessió generada sense
            transaction_id.
        file_name:
          type: string
          nullable: true
        content_type:
          type: string
          nullable: true
        screenshot_url:
          type: string
          nullable: true
          description: >-
            Enllaç de durada limitada a la captura de pantalla pujada. Torna a
            llistar la cua per obtenir un enllaç actualitzat.
        attempts:
          type: integer
          description: Quants fitxers ha pujat l'usuari final per a aquest comprovant.
        failure_reason:
          allOf:
            - $ref: '#/components/schemas/TravelRuleWalletProofFailureReason'
          description: >-
            REVIEW_REJECTED després d'un rebuig, OWNERSHIP_CHANGED quan la
            cartera ha canviat de titular o s'ha eliminat abans d'una decisió.
            Buit en cas contrari.
        method_chosen_at:
          type: string
          format: date-time
          nullable: true
          description: Quan l'usuari final va triar el mètode de captura de pantalla.
        decided_at:
          type: string
          format: date-time
          nullable: true
        decided_by:
          type: string
          description: >-
            Qui ha tancat la prova: review:<user identifier> per a un revisor de
            la consola, review per a una decisió amb clau d'API, widget o
            sweeper quan Didit l'ha tancat automàticament. Buit mentre estigui
            en PENDING.
        review_note:
          type: string
          description: La nota enviada amb la decisió. Buida quan no n'hi ha cap.
        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: >-
        Per què una prova de titularitat de la cartera, o el seu últim intent,
        no ha arribat a VERIFIED. Buit si no ha fallat res. Una prova PENDING en
        pot contenir un: l'últim intent ha fallat i l'usuari final pot tornar-ho
        a provar. DEPOSIT_MISMATCH, DEPOSIT_STALE, TXID_REUSED i REVIEW_REJECTED
        tanquen la prova com a REJECTED. SIGNATURE_INVALID: la signatura no
        coincideix amb la cartera i el repte. SIGNATURE_UNSUPPORTED_SCHEME: la
        cartera ha signat en un format que Didit no verifica. DEPOSIT_NOT_FOUND,
        DEPOSIT_UNCONFIRMED, DEPOSIT_LOOKUP_FAILED: el dipòsit de prova no es
        pot llegir o encara no està confirmat; Didit continua comprovant-lo fins
        que es tanca la finestra de prova. DEPOSIT_MISMATCH: la transacció no
        envia l'import esperat des de la cartera a l'adreça de dipòsit.
        DEPOSIT_STALE: la transacció és anterior al repte. TXID_REUSED: la
        transacció ja ha provat una altra cartera. CHAIN_UNSUPPORTED: el mètode
        no està disponible en aquesta cadena. WINDOW_EXPIRED: la finestra de
        prova s'ha tancat. OWNERSHIP_CHANGED: el titular de la cartera ha
        canviat, o la cartera s'ha suprimit de la teva llibreta d'adreces,
        després que s'hagués generat la sessió del widget. METHOD_SWITCHED:
        l'usuari final ha triat un altre mètode abans d'acabar aquest.
        REVIEW_REJECTED: el teu revisor ha rebutjat la captura de pantalla.
        ABANDONED: la sessió del widget ha caducat abans que l'usuari final
        acabés.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clau d'API de la teva aplicació, des de Developers -> API keys a la
        Business Console. La clau primària té accés complet. Una clau amb nom
        pot tenir l'abast limitat: cap, lectura o escriptura per recurs,
        limitada a determinats fluxos de treball o a sessions aprovades, a una
        llista d'adreces IP i a una data de caducitat. 401 significa que la clau
        és incorrecta, revocada o caducada; 403 significa que no s'ha enviat cap
        clau, que la clau no té accés a aquest recurs o acció, o que la
        sol·licitud prové d'una adreça fora de la seva llista d'IP; 404 en una
        ruta de sessió significa que la sessió està fora dels fluxos de treball
        o estats de la clau. Una clau sense accés a fitxers multimèdia rep els
        URL d'imatge, vídeo i PDF com a null, i una clau sense permís
        d'escriptura de sessions rep els enllaços de sessió i els tokens com a
        null. Consulta https://docs.didit.me/console/api-keys.

````

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