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

# Aprovar o rebutjar prova de cartera per captura, API

> Aprova o rebutja amb Didit una prova de cartera per captura de pantalla. L'aprovació verifica la cartera i aplica la titularitat a la transferència vinculada.

Prompt de l'API Decide Wallet Proof
Copia el prompt al porta-retalls

<pre>
  \`Approve or reject a screenshot wallet-ownership proof from my review queue.

  Endpoint:
  POST [https://verification.didit.me/v3/travel-rule/wallet-proofs/\{proof\_uuid}/decision/](https://verification.didit.me/v3/travel-rule/wallet-proofs/\{proof_uuid}/decision/)

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

  Body:

  * decision - "approve" or "reject".
  * note - optional, up to 512 characters, kept with the proof and returned as review\_note.

  Behavior:

  * approve verifies the proof and the wallet address book entry, and applies the ownership to the transfer the widget session was minted for, exactly as a verified signature does.
  * A screenshot never confirms a transfer another Didit customer sent over the INTERNAL rail: that needs a signed message or a test deposit.
  * reject closes the proof as REJECTED with failure\_reason REVIEW\_REJECTED. It uses one of the widget session's attempts; the end user can start a new proof from the widget while attempts remain. Your note is never shown to the end user.
  * Returns the decided proof, in the same shape as the review queue.

  Failure modes:

  * 404 - no submitted screenshot proof with this id in my application.
  * 409 - already decided (the body carries its status), or code OWNERSHIP\_CHANGED when the wallet's holder changed or the wallet was deleted after the widget session was minted; ask the current holder for a new proof.
  * 400 - invalid decision or a note that is too long.
  * 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 POST /v3/travel-rule/wallet-proofs/{proof_uuid}/decision/
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/{proof_uuid}/decision/:
    post:
      tags:
        - Travel Rule
      summary: Aprova o rebutja un comprovant de cartera per captura de pantalla
      description: >-
        Pren una decisió sobre una prova de captura de pantalla de la teva cua
        de revisió. approve verifica la prova i l'entrada de la llibreta
        d'adreces i aplica la titularitat a la transferència per a la qual es va
        generar la sessió del widget, exactament igual que fa una signatura
        verificada. Una captura de pantalla mai confirma una transferència que
        un altre client de Didit hagi enviat a través del canal INTERNAL: això
        requereix un missatge signat o un dipòsit de prova. reject tanca la
        prova com a REJECTED amb failure_reason REVIEW_REJECTED; l'usuari final
        pot iniciar una nova prova des del widget. La nota es conserva amb la
        prova.
      operationId: decideTravelRuleWalletProof
      parameters:
        - name: proof_uuid
          in: path
          required: true
          description: proof_id de la cua de revisió.
          schema:
            type: string
            format: uuid
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TravelRuleWalletProofDecision'
            example:
              decision: approve
              note: Address matches the wallet app.
      responses:
        '200':
          description: El comprovant determinat.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleWalletProofReview'
        '400':
          description: Decisió no vàlida o una nota de més de 512 caràcters.
        '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.
        '404':
          description: >-
            No hi ha cap comprovant de captura de pantalla enviat amb aquest ID
            a la teva aplicació.
        '409':
          description: >-
            La prova ja està decidida (el cos inclou el seu estat), o codi
            OWNERSHIP_CHANGED: el titular de la cartera ha canviat o la cartera
            s'ha eliminat després que es generés la sessió del widget, de manera
            que la prova està tancada i el titular actual en necessita una de
            nova.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TravelRuleWidgetProofError'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            https://verification.didit.me/v3/travel-rule/wallet-proofs/{proof_uuid}/decision/
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"decision": "approve", "note": "Address matches the wallet app."}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.travel_rule.wallet_proofs.decide(
                "11111111-2222-3333-4444-555555555555",
                decision="approve",
                note="Address matches the wallet app.",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: >-
            import Didit from "@didit-protocol/sdk-node";


            // Reads DIDIT_API_KEY.

            const didit = new Didit();


            const result = await
            didit.travelRule.walletProofs.decide("11111111-2222-3333-4444-555555555555",
            {
              decision: "approve",
              note: "Address matches the wallet app.",
            });

            console.log(result);
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;

            import me.didit.types.TravelRuleWalletProofDecision;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.travelRule().walletProofs().decide("11111111-2222-3333-4444-555555555555",
            TravelRuleWalletProofDecision.builder()
                    .decision(TravelRuleWalletProofDecision.Decision.of("approve"))
                    .note("Address matches the wallet app.")
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $result =
            $didit->travelRule->walletProofs->decide('11111111-2222-3333-4444-555555555555',
            [
                'decision' => 'approve',
                'note' => 'Address matches the wallet app.',
            ]);

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.travel_rule.wallet_proofs.decide(
              "11111111-2222-3333-4444-555555555555",
              decision: "approve",
              note: "Address matches the wallet app."
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await
            client.TravelRule.WalletProofs.DecideAsync("11111111-2222-3333-4444-555555555555",
            new TravelRuleWalletProofDecision

            {
                Decision = "approve",
                Note = "Address matches the wallet app.",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TravelRuleWalletProofDecision:
      type: object
      required:
        - decision
      properties:
        decision:
          type: string
          enum:
            - approve
            - reject
        note:
          type: string
          maxLength: 512
          description: Opcional. Es conserva amb la prova i es retorna com a review_note.
    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
    TravelRuleWidgetProofError:
      type: object
      properties:
        detail:
          type: string
          description: Missatge fàcil de llegir en anglès.
        code:
          allOf:
            - $ref: '#/components/schemas/TravelRuleWalletProofFailureReason'
          description: >-
            Motiu llegible per màquina, perquè un client pugui mostrar el seu
            propi missatge traduït.
        status:
          type: string
          enum:
            - PENDING
            - VERIFIED
            - REJECTED
            - EXPIRED
          description: >-
            Present quan la prova està tancada: REJECTED pel dipòsit que s'acaba
            d'enviar (400), o REJECTED o EXPIRED quan s'envien evidències a una
            prova que ja està tancada (409).
        proof_id:
          type: string
          format: uuid
          description: 'Present amb estat: la prova tancada.'
        method:
          type: string
          enum:
            - MESSAGE_SIGNING
            - SATOSHI_TEST
            - SCREENSHOT
            - SELF_DECLARATION
          description: 'Present amb estat: el mètode de la prova tancada.'
        max_attempts:
          type: integer
          description: >-
            Present amb estat: proves de cartera rebutjades que permet aquesta
            sessió.
        attempts_used:
          type: integer
          description: 'Present amb estat: proves rebutjades fins ara.'
        attempts_remaining:
          type: integer
          description: >-
            Present amb estat: quan és 0, iniciar una altra prova respon 409 i
            es genera una nova sessió del widget.
    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.