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

> Didit के साथ अपने सिस्टम से निगरानी किए गए लेन-देन की समीक्षा टाइमलाइन में सादा-पाठ नोट जोड़ें, वैकल्पिक सदस्य उल्लेख सहित।



लेन-देन नोट बनाने का API प्रॉम्प्ट
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Add a note to a Didit monitored transaction through the Management API.

Endpoint:
POST https://verification.didit.me/v3/transactions/{transaction_id}/notes/

Authentication:
Use the x-api-key header with my Didit API key. A scoped key needs transactions: write. Keys limited to specific workflows or to approved sessions cannot call this endpoint.

Goal:
\- Record context from my own systems (a support call, a manual check, an outcome from my case tool) on the transaction's review timeline, where Console reviewers see it.

Path parameter:
\- transaction_id: the Didit transaction uuid, not my own txn_id.

Request body (application/json):
\{
"note": "Customer confirmed the withdrawal by phone.",
"mentioned_emails": ["analyst@example.com"]
}
\- note: required. Plain text, no length limit. Leading and trailing whitespace is trimmed and a blank note is rejected.
\- mentioned_emails: optional list of emails of members of my organization to mention.

Behavior:
\- Returns 201 with the created note. actor_email and actor_name are null because the note comes from an API key, not a person.
\- Every mentioned email must belong to a member of my organization; one unknown address fails the whole request with 400. Mentions are stored lower-cased and de-duplicated in metadata.mentioned_emails. This endpoint does not notify the mentioned members.
\- Each call creates a new note. Retrying a request that timed out can add the same note twice, so check GET /v3/transactions/{transaction_id}/notes/ before retrying.
\- There is no API endpoint to edit or remove a note.

Example call:
curl -X POST "https://verification.didit.me/v3/transactions/{transaction_id}/notes/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"note": "Customer confirmed the withdrawal by phone.", "mentioned_emails": ["analyst@example.com"]}'

What to read from the response:
\- uuid: the note id.
\- created_at: when the note was stored.
\- metadata.mentioned_emails: the normalized mention list (empty when nobody was mentioned).

Failure modes:
\- 400: note missing ({"note": ["This field is required."]}) or blank, an invalid email in mentioned_emails, or a mentioned address outside my organization ({"mentioned_emails": ["Mentioned users must belong to this organization and have access to this application."]}).
\- 401: the API key has expired.
\- 403: missing API key (a wrong, revoked or expired key gets 401), a scoped key without transactions: write ({"detail": "This API key has no write access to transactions."}), a key with workflow or status limits, or a request from outside the key's IP allowlist.
\- 404: no transaction with this uuid in my application ({"detail": "No Transaction matches the given query."}).
\- 429: more than 300 write requests per minute with this key; wait Retry-After seconds and retry.

Side effects: creates the note and adds a TRANSACTION_NOTE_ADDED entry to the transaction's activities. The transaction's status, score and alerts do not change, no webhook is sent, and nothing is billed.

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

यहाँ पेस्ट करें

नोट संदर्भ के लिए है, निर्णय के लिए नहीं: यह लेन-देन के `status`, `score` या अलर्ट को कभी नहीं बदलता। समीक्षक इसे कंसोल में [लेन-देन विवरण](https://docs.didit.me/hi/transaction-monitoring/console.md#लेन-देन-विवरण) पर **नोट्स** के अंतर्गत देखते हैं, और लेन-देन की `activities` में एक `TRANSACTION_NOTE_ADDED` प्रविष्टि जुड़ जाती है, जिसे आप [लेन-देन प्राप्त करें](https://docs.didit.me/hi/management-api/transactions/get.md) से पढ़ सकते हैं।चूँकि नोट एक API कुंजी से आता है, इसमें कोई लेखक नहीं होता: `actor_email` और `actor_name` `null` होते हैं। यदि आपको दिखाना है कि इसे किसने लिखा, तो यह जानकारी नोट के टेक्स्ट में शामिल करें। [लेन-देन के नोट्स की सूची प्राप्त करें](https://docs.didit.me/hi/management-api/transactions/list-notes.md) से पूरी टाइमलाइन दोबारा पढ़ें।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/transactions/{transaction_id}/notes/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: पहचान सत्यापन API। x-api-key हेडर के साथ प्रमाणीकृत करें।
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/transactions/{transaction_id}/notes/:
    post:
      tags:
        - Transactions
      summary: लेन-देन नोट बनाएं
      description: >-
        निगरानी किए जा रहे लेन-देन की समीक्षा टाइमलाइन में एक सादा-टेक्स्ट नोट
        जोड़ें, जहां कंसोल समीक्षक इसे देख सकते हैं। एक नोट केवल संदर्भ है, कोई
        निर्णय नहीं: लेन-देन का `status`, `score` और अलर्ट नहीं बदलते हैं, कोई
        webhook नहीं भेजा जाता है, और कुछ भी बिल नहीं किया जाता है। लेन-देन की
        `activities` में एक `TRANSACTION_NOTE_ADDED` प्रविष्टि जुड़ जाती है।


        API कुंजी के साथ बनाए गए नोटों का कोई लेखक नहीं होता है: `actor_email`
        और `actor_name` `null` होते हैं, इसलिए यदि आपको आवश्यकता हो तो लेखक को
        टेक्स्ट में शामिल करें। `mentioned_emails` में प्रत्येक पता आपके संगठन
        के किसी सदस्य का होना चाहिए, अन्यथा पूरा अनुरोध `400` के साथ विफल हो
        जाता है; उल्लेखों को लोअरकेस में और डुप्लिकेट हटाकर संग्रहीत किया जाता
        है, और यह endpoint उल्लिखित सदस्यों को सूचित नहीं करता है।


        प्रत्येक कॉल एक नया नोट बनाती है, इसलिए समय-सीमा समाप्त अनुरोध का पुनः
        प्रयास करने पर यह दो बार जुड़ सकता है: पुनः प्रयास करने से पहले नोटों को
        सूचीबद्ध करें। किसी नोट को संपादित करने या हटाने के लिए कोई API endpoint
        नहीं है। स्कोप्ड API कुंजी के लिए `transactions: write` की आवश्यकता होती
        है; कुछ वर्कफ़्लो या स्वीकृत सत्रों तक सीमित कुंजी इस endpoint को कॉल
        नहीं कर सकती है।
      operationId: create_transaction_note
      parameters:
        - name: transaction_id
          in: path
          required: true
          description: >-
            Didit लेन-देन UUID: `POST /v3/transactions/` और `GET
            /v3/transactions/` द्वारा लौटाया गया `uuid`। आपकी अपनी `txn_id`
            स्वीकार नहीं की जाती है।
          schema:
            type: string
            format: uuid
          example: abcdef12-3456-7890-abcd-ef1234567890
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - note
              properties:
                note:
                  type: string
                  minLength: 1
                  description: >-
                    सादा टेक्स्ट नोट। शुरुआत और अंत के रिक्त स्थान को हटा दिया
                    जाता है और खाली नोट को अस्वीकार कर दिया जाता है। कोई लंबाई
                    सीमा नहीं।
                mentioned_emails:
                  type: array
                  items:
                    type: string
                    format: email
                  default: []
                  description: >-
                    मेंशन करने के लिए आपके संगठन के सदस्यों के ईमेल। प्रत्येक
                    आपके संगठन के सदस्य का एक मान्य ईमेल होना चाहिए।
            examples:
              Note with a mention:
                value:
                  note: Customer confirmed the withdrawal by phone.
                  mentioned_emails:
                    - analyst@example.com
              Plain note:
                value:
                  note: Source of funds document requested by email.
      responses:
        '201':
          description: नोट बनाया गया था।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TransactionNote'
              examples:
                Created:
                  value:
                    uuid: c1111111-2222-4333-8444-555555555555
                    note: Customer confirmed the withdrawal by phone.
                    actor_email: null
                    actor_name: null
                    metadata:
                      mentioned_emails:
                        - analyst@example.com
                    created_at: '2026-10-16T10:05:12.481203Z'
        '400':
          description: >-
            बॉडी अमान्य है: `note` अनुपलब्ध, null या रिक्त है,
            `mentioned_emails` में अमान्य पता है (सूची स्थिति द्वारा कीड की गई
            त्रुटियाँ), या ऐसा उल्लिखित पता जो आपके संगठन का सदस्य नहीं है। कुछ
            भी नहीं बनाया गया है।
          content:
            application/json:
              schema:
                type: object
                description: फ़ील्ड नाम के अनुसार कुंजीबद्ध फ़ील्ड त्रुटियाँ।
                additionalProperties: {}
              examples:
                Missing note:
                  value:
                    note:
                      - This field is required.
                Blank note:
                  value:
                    note:
                      - This field may not be blank.
                Invalid email:
                  value:
                    mentioned_emails:
                      '0':
                        - Enter a valid email address.
                Not an organization member:
                  value:
                    mentioned_emails:
                      - >-
                        Mentioned users must belong to this organization and
                        have access to this application.
        '401':
          description: >-
            API कुंजी की समय-सीमा समाप्त हो गई है। केवल समाप्ति तिथि के साथ बनाई
            गई कुंजी ही समाप्त हो सकती है; उस तिथि के बाद इसके साथ किया गया
            प्रत्येक अनुरोध `401` रिस्पॉन्स देता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Expired key:
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            अनुरोध की अनुमति नहीं है। एक अनुपलब्ध कुंजी को सामान्य संदेश मिलता
            है; एक गलत, निरस्त या समय-सीमा समाप्त कुंजी को `401` मिलता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Missing or invalid key:
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without transactions write:
                  value:
                    detail: This API key has no write access to transactions.
                Key limited to workflows or approved sessions:
                  value:
                    detail: >-
                      This API key only reaches sessions inside its workflow or
                      status limits, so it can't use this endpoint.
                Outside the key's IP list:
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            एप्लिकेशन में इस UUID वाला कोई लेन-देन मौजूद नहीं है (कभी नहीं बनाया
            गया, हटा दिया गया, या किसी अन्य एप्लिकेशन के स्वामित्व में है)। एक
            `transaction_id` जो UUID नहीं है, API तक नहीं पहुंचता है: यह इस JSON
            बॉडी के बजाय `404` HTML पेज लौटाता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Not found:
                  value:
                    detail: No Transaction matches the given query.
        '429':
          description: >-
            इस API कुंजी के साथ प्रति मिनट 300 से अधिक राइट अनुरोध।
            `Retry-After` में दिए गए सेकंड तक प्रतीक्षा करें, फिर पुनः प्रयास
            करें।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Throttled:
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
          headers:
            Retry-After:
              description: वर्तमान एक-मिनट की विंडो रीसेट होने तक के सेकंड।
              schema:
                type: integer
                example: 23
            X-RateLimit-Limit:
              description: इस बजट में प्रति मिनट अनुमत अनुरोध।
              schema:
                type: integer
            X-RateLimit-Remaining:
              description: वर्तमान विंडो में शेष अनुरोध।
              schema:
                type: integer
            X-RateLimit-Reset:
              description: Unix समय जब विंडो रीसेट होती है।
              schema:
                type: integer
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/transactions/abcdef12-3456-7890-abcd-ef1234567890/notes/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"note": "Customer confirmed the withdrawal by phone.", "mentioned_emails": ["analyst@example.com"]}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.transactions.notes.create(
                "abcdef12-3456-7890-abcd-ef1234567890",
                note="Customer confirmed the withdrawal by phone.",
                mentioned_emails=["analyst@example.com"],
            )
            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.transactions.notes.create("abcdef12-3456-7890-abcd-ef1234567890",
            {
              note: "Customer confirmed the withdrawal by phone.",
              mentioned_emails: ["analyst@example.com"],
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.Notes.Create(ctx, \"abcdef12-3456-7890-abcd-ef1234567890\", didit.TransactionsNotesCreateParams{\n\tNote:            \"Customer confirmed the withdrawal by phone.\",\n\tMentionedEmails: didit.Some([]string{\"analyst@example.com\"}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.TransactionsNotesCreateParams;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.transactions().notes().create("abcdef12-3456-7890-abcd-ef1234567890",
            TransactionsNotesCreateParams.builder()
                    .note("Customer confirmed the withdrawal by phone.")
                    .mentionedEmails(List.of("analyst@example.com"))
                    .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->transactions->notes->create('abcdef12-3456-7890-abcd-ef1234567890',
            [
                'note' => 'Customer confirmed the withdrawal by phone.',
                'mentioned_emails' => ['analyst@example.com'],
            ]);

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

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

            result = didit.transactions.notes.create(
              "abcdef12-3456-7890-abcd-ef1234567890",
              note: "Customer confirmed the withdrawal by phone.",
              mentioned_emails: ["analyst@example.com"]
            )
            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.Transactions.Notes.CreateAsync("abcdef12-3456-7890-abcd-ef1234567890",
            new TransactionsNotesCreateParams

            {
                Note = "Customer confirmed the withdrawal by phone.",
                MentionedEmails = new string[] { "analyst@example.com" },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    TransactionNote:
      type: object
      description: निगरानी किए गए लेन-देन की समीक्षा टाइमलाइन पर एक नोट।
      required:
        - uuid
        - note
        - actor_email
        - actor_name
        - metadata
        - created_at
      properties:
        uuid:
          type: string
          format: uuid
          description: नोट पहचानकर्ता।
        note:
          type: string
          description: सादे टेक्स्ट वाले नोट का मुख्य भाग।
        actor_email:
          type: string
          format: email
          nullable: true
          description: >-
            उस कंसोल उपयोगकर्ता का ईमेल जिसने नोट लिखा या स्थिति बदली। API कुंजी
            से बनाए गए नोटों और Didit द्वारा स्वचालित रूप से जोड़े गए नोटों के
            लिए `null`।
        actor_name:
          type: string
          nullable: true
          description: >-
            Console उपयोगकर्ता का डिस्प्ले नाम (यदि कोई नाम नहीं है तो उनका
            ईमेल)। Didit द्वारा स्वचालित रूप से जोड़े गए नोट्स पर `Rule Engine`।
            API कुंजी के साथ बनाए गए नोट्स के लिए `null`।
        metadata:
          type: object
          description: >-
            नोट के प्रकारों में अंतर बताता है। API या कंसोल के माध्यम से लिखे गए
            नोटों में `mentioned_emails` शामिल होता है। कंसोल में किए गए स्थिति
            परिवर्तन में `previous_status`, `new_status`, `reason_code` और
            `reason_label` के साथ `type: status_change` शामिल होता है। Didit
            द्वारा जोड़े गए नोटों में `source` शामिल होता है: किसी नियम की
            `add_note` कार्रवाई के लिए `rule_action` (`rule_uuid` के साथ), या
            उपयोगकर्ता-कार्रवाई सत्यापन सत्र बनाने में किसी समस्या के लिए
            `remediation_session`।
          properties:
            mentioned_emails:
              type: array
              items:
                type: string
                format: email
              description: >-
                उल्लिखित संगठन के सदस्य, लोअर-केस में किए गए और डुप्लिकेट हटाए
                गए। किसी का उल्लेख न होने पर खाली।
            type:
              type: string
              enum:
                - status_change
              description: >-
                कंसोल में किए गए स्थिति परिवर्तन को रिकॉर्ड करने वाले नोट्स में
                मौजूद।
            previous_status:
              type: string
              enum:
                - APPROVED
                - IN_REVIEW
                - DECLINED
                - AWAITING_USER
              description: परिवर्तन से पहले की स्थिति।
            new_status:
              type: string
              enum:
                - APPROVED
                - IN_REVIEW
                - DECLINED
                - AWAITING_USER
              description: परिवर्तन के बाद की स्थिति।
            reason_code:
              type: string
              nullable: true
              description: परिवर्तन के साथ दिया गया कारण कोड।
            reason_label:
              type: string
              nullable: true
              description: परिवर्तन के साथ दिया गया कारण लेबल।
            source:
              type: string
              enum:
                - rule_action
                - remediation_session
              description: Didit द्वारा स्वचालित रूप से जोड़े गए नोट्स में मौजूद।
            rule_uuid:
              type: string
              format: uuid
              description: >-
                वह नियम जिसकी `add_note` कार्रवाई ने नोट लिखा (`source:
                rule_action` के साथ)।
        created_at:
          type: string
          format: date-time
          description: नोट कब संग्रहीत किया गया था।
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        आपकी एप्लिकेशन की API कुंजी, Business Console में Developers -> API keys
        से। प्राथमिक कुंजी के पास पूर्ण एक्सेस होता है। एक नामित कुंजी को स्कोप
        किया जा सकता है: प्रति संसाधन none, read या write, कुछ वर्कफ़्लो या
        स्वीकृत सत्रों तक सीमित, IP पतों की सूची तक सीमित, और समाप्ति तिथि तक
        सीमित। 401 का अर्थ है कि कुंजी गलत है, निरस्त कर दी गई है या उसकी
        समय-सीमा समाप्त हो गई है; 403 का अर्थ है कि कोई कुंजी नहीं भेजी गई थी,
        कुंजी के पास इस संसाधन या कार्रवाई का एक्सेस नहीं है, या अनुरोध उसकी IP
        सूची से बाहर के पते से आया था; सत्र रूट पर 404 का अर्थ है कि सत्र कुंजी
        के वर्कफ़्लो या स्थितियों से बाहर है। मीडिया एक्सेस के बिना एक कुंजी को
        छवि, वीडियो और PDF URL null के रूप में प्राप्त होते हैं, और सत्र write
        के बिना एक कुंजी को सत्र लिंक और token null के रूप में प्राप्त होते हैं।
        देखें https://docs.didit.me/console/api-keys।

````

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