> ## 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>
  \`Read the event timeline of one Didit verification session through the API.

  Endpoint:
  GET [https://verification.didit.me/v3/session/\{session\_id}/events/](https://verification.didit.me/v3/session/\{session_id}/events/)

  Authentication:
  Send my Didit API key in the x-api-key header. A scoped key needs sessions: read and decisions: read.

  Goal:

  * See what happened during a session, step by step: which screens the user saw, where they stopped, which attempts failed, when the status changed and how the workflow routed the session.

  Behavior:

  * Works for user (KYC) and business (KYB) session IDs.
  * Ordered by sent\_at, newest first. sent\_at is a Unix timestamp in milliseconds.
  * Paginated with limit (default 50) and offset. The response is { count, next, previous, results }. Follow next until it is null.
  * Device-reported event types: LINK\_OPENED, STEP\_RENDERED, BUTTON\_CLICKED, FORM\_SUBMITTED, FILE\_UPLOADED, ATTEMPT\_FAILED, LOG. Server-recorded types include SESSION\_CREATED, SESSION\_STATUS\_CHANGED (details.old\_status, details.current\_status), FEATURE\_STEP\_CHANGED, WORKFLOW\_BRANCH\_EVALUATED and WORKFLOW\_STATUS\_NODE\_REACHED.
  * Events are stored asynchronously, so a new event can take a few seconds to appear.
  * file\_url is a short-lived presigned link; a scoped key without media: read receives it as null.

  Example call:
  curl -X GET "[https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/events/?limit=50](https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/events/?limit=50)" \
  -H "x-api-key: YOUR\_API\_KEY"

  What to read from the response:

  * results\[].event\_type, feature\_step (OCR, LIVENESS, FACE\_MATCH, ...) and step (the screen, for example DOCUMENT\_CAPTURE\_FRONT).
  * results\[].details: event-specific data; the keys vary by event\_type.
  * results\[].ip\_address, user\_agent and device\_info for device-reported events.
  * count, next and previous for pagination.

  Failure modes:

  * 400: limit or offset above 1,000,000.
  * 401: the API key has expired.
  * 403: missing key (a wrong, revoked or expired key gets 401), a key of another application, a scoped key without the permissions above, or a request from outside the key's IP allowlist.
  * 404: the session does not exist, was deleted, or is outside a scoped key's workflow or status limits.

  Side effects: none. This is a pure read.

  For the full integration shape, see /integration/integration-prompt.\`
</pre>

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

वर्कफ़्लो रूटिंग इवेंट (`WORKFLOW_BRANCH_EVALUATED`, `WORKFLOW_STATUS_NODE_REACHED`) और उनके `details` का विवरण [सत्र प्राप्त करें](https://docs.didit.me/hi/sessions-api/retrieve-session.md) में दिया गया है। वहाँ `?include=events` के साथ उपयोगकर्ता सत्यापन (KYC) सत्र के निर्णय के अंदर उसकी टाइमलाइन भी लौटाई जा सकती है।


## OpenAPI

````yaml hi/openapi-25.json GET /v3/session/{sessionId}/events/
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/session/{sessionId}/events/:
    get:
      tags:
        - Sessions
      summary: सत्र इवेंट सूचीबद्ध करें
      description: >-
        एक सत्यापन सत्र की इवेंट टाइमलाइन पढ़ें, `sent_at` के अनुसार सबसे नया
        पहले: उपयोगकर्ता द्वारा देखी गई स्क्रीन, बटन और अपलोड, विफल प्रयास,
        स्थिति और सुविधा-चरण परिवर्तन, और वर्कफ़्लो रूटिंग ट्रेस। उपयोगकर्ता
        सत्यापन (KYC) और व्यवसाय सत्यापन (KYB) सत्र ID के लिए काम करता है। इवेंट
        एसिंक्रोनस रूप से संग्रहीत होते हैं, इसलिए किसी नए इवेंट को प्रदर्शित
        होने में कुछ सेकंड लग सकते हैं। परिणाम `limit` और `offset` के साथ
        पेजिनेटेड होते हैं; जब तक यह `null` न हो जाए तब तक `next` का अनुसरण
        करें। स्कोप्ड API कुंजी के लिए `sessions: read` और `decisions: read`
        आवश्यक हैं, और `media: read` के बिना यह `file_url` को `null` के रूप में
        प्राप्त करती है। रूटिंग इवेंट का वर्णन [सत्र प्राप्त
        करें](https://docs.didit.me/hi/sessions-api/retrieve-session) में किया
        गया है।
      operationId: get_v3_session_events
      parameters:
        - name: sessionId
          in: path
          required: true
          description: >-
            सत्यापन सत्र का UUID (`POST /v3/session/` द्वारा लौटाया गया
            `session_id`)। उपयोगकर्ता सत्यापन (KYC) और व्यवसाय सत्यापन (KYB)
            दोनों सत्र ID स्वीकार करता है: सर्वर दोनों सत्र प्रकारों में ID को
            रिज़ॉल्व करता है। यह एक सही प्रारूप वाला UUID होना चाहिए; गलत
            प्रारूप वाला मान रूट से मेल नहीं खाता है और एक HTML `404` लौटाता है।
          schema:
            type: string
            format: uuid
            example: 11111111-2222-3333-4444-555555555555
        - name: limit
          in: query
          required: false
          description: >-
            प्रति पेज इवेंट की अधिकतम संख्या। डिफ़ॉल्ट 50 है। 1 से कम मान या
            गैर-संख्यात्मक मान वापस 50 हो जाता है; 1,000,000 से अधिक मान `400`
            लौटाता है।
          schema:
            type: integer
            default: 50
            minimum: 1
            maximum: 1000000
            example: 50
        - name: offset
          in: query
          required: false
          description: >-
            पहले लौटाए गए परिणाम से पहले छोड़े जाने वाले परिणामों की संख्या।
            डिफ़ॉल्ट रूप से 0; ऋणात्मक या गैर-संख्यात्मक मान वापस 0 पर आ जाता
            है, 1,000,000 से अधिक मान `400` लौटाता है। `next` और `previous` URL
            का अनुसरण करना बेहतर है।
          schema:
            type: integer
            default: 0
            minimum: 0
            maximum: 1000000
            example: 0
        - name: ordering
          in: query
          required: false
          description: >-
            वैकल्पिक सॉर्ट ओवरराइड। डिफ़ॉल्ट क्रम `-sent_at` है। आरोही क्रम में
            सॉर्ट करने के लिए परिणाम फ़ील्ड नाम (उदाहरण के लिए `sent_at`,
            `created_at`, `event_type`, `feature_step` या `step`) पास करें,
            अवरोही क्रम में सॉर्ट करने के लिए इसके आगे `-` लगाएं, और कई फ़ील्ड्स
            को अल्पविराम से अलग करें। अज्ञात फ़ील्ड्स को अनदेखा कर दिया जाता है।
          schema:
            type: string
            example: sent_at
      responses:
        '200':
          description: सत्र के इवेंट्स का एक पेज, सबसे नया पहले।
          content:
            application/json:
              schema:
                type: object
                required:
                  - count
                  - next
                  - previous
                  - results
                properties:
                  count:
                    type: integer
                    description: सत्र के इवेंट की कुल संख्या।
                  next:
                    type: string
                    format: uri
                    nullable: true
                    description: अगले पेज का URL, या अंतिम पेज पर `null`।
                  previous:
                    type: string
                    format: uri
                    nullable: true
                    description: पिछले पेज का URL, या पहले पेज पर `null`।
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/SessionEvent'
              examples:
                Completed session:
                  value:
                    count: 3
                    next: null
                    previous: null
                    results:
                      - uuid: aaaaaaaa-1111-2222-3333-444444444444
                        event_type: SESSION_STATUS_CHANGED
                        created_at: '2026-09-14T10:02:13.904512Z'
                        component: null
                        feature_step: null
                        step: null
                        details:
                          old_status: In Progress
                          current_status: Approved
                        ip_address: null
                        user_agent: null
                        device_info: null
                        file_url: null
                        sent_at: 1789380131482
                      - uuid: bbbbbbbb-1111-2222-3333-444444444444
                        event_type: FEATURE_STEP_CHANGED
                        created_at: '2026-09-14T10:01:49.210377Z'
                        component: null
                        feature_step: null
                        step: null
                        details:
                          old_feature_step: OCR
                          current_feature_step: LIVENESS
                        ip_address: null
                        user_agent: null
                        device_info: null
                        file_url: null
                        sent_at: 1789380107103
                      - uuid: cccccccc-1111-2222-3333-444444444444
                        event_type: STEP_RENDERED
                        created_at: '2026-09-14T10:01:00.581930Z'
                        component: DocumentCapture
                        feature_step: OCR
                        step: DOCUMENT_CAPTURE_FRONT
                        details: {}
                        ip_address: 203.0.113.24
                        user_agent: >-
                          Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X)
                          AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5
                          Mobile/15E148 Safari/604.1
                        device_info:
                          device_model: iPhone
                        file_url: null
                        sent_at: 1789380058776
        '400':
          description: >-
            `limit` या `offset` 1,000,000 से अधिक है। बॉडी एक संदेश वाला JSON
            ऐरे है।
          content:
            application/json:
              examples:
                Limit too large:
                  summary: limit=2000000
                  value:
                    - limit must not exceed 1000000.
                Offset too large:
                  summary: offset=2000000
                  value:
                    - offset must not exceed 1000000.
              schema:
                type: array
                items:
                  type: string
        '401':
          description: >-
            स्कोप्ड API कुंजी की समय-सीमा समाप्त हो गई है। यह एकमात्र मामला है
            जो `401` लौटाता है: अनुपलब्ध, अमान्य या निरस्त कुंजी `403` लौटाती
            है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Expired key:
                  summary: कुंजी की समाप्ति तिथि बीत चुकी है
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            प्रमाणीकरण या प्राधिकरण विफलता। अनुपस्थित कुंजी `403` लौटाती है, और
            किसी अन्य एप्लिकेशन की कुंजी, इस endpoint के लिए आवश्यक अनुमति के
            बिना वाली स्कोप्ड कुंजी, तथा कुंजी की IP अनुमति सूची (allowlist) के
            बाहर से किया गया अनुरोध भी यही लौटाता है; गलत, निरस्त या समय-सीमा
            समाप्त कुंजी `401` लौटाती है। उन्हें `detail` द्वारा पहचानें।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Missing or invalid credentials:
                  summary: कोई x-api-key हेडर नहीं है, या कुंजी सत्यापन में विफल रही
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Other application:
                  summary: एक मान्य कुंजी जो सत्र से भिन्न एप्लिकेशन से संबंधित है
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without sessions read:
                  summary: 'स्कोप्ड कुंजी में sessions: read की कमी है'
                  value:
                    detail: This API key has no read access to sessions.
                Scoped key without decisions read:
                  summary: 'स्कोप्ड कुंजी में decisions: read की कमी है'
                  value:
                    detail: This API key has no read access to decisions.
                IP not allowed:
                  summary: कुंजी की IP अनुमति सूची से बाहर का अनुरोध
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            सत्र मौजूद नहीं है, हटा दिया गया था, या स्कोप्ड कुंजी के वर्कफ़्लो
            या केवल-स्वीकृत सीमाओं से बाहर है। सत्र लुकअप क्रेडेंशियल जांच से
            पहले चलता है, इसलिए एक अज्ञात `sessionId` वैध कुंजी के बिना भी `404`
            लौटाता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Unknown session:
                  summary: इस ID वाला कोई सत्र मौजूद नहीं है, या इसे हटा दिया गया था
                  value:
                    detail: Not found.
                Outside key limits:
                  summary: >-
                    सत्र स्कोप्ड कुंजी के वर्कफ़्लो या केवल-स्वीकृत सीमाओं से
                    बाहर है
                  value:
                    detail: Session not found.
        '429':
          description: >-
            रेट लिमिट पार हो गई: प्रति API कुंजी प्रति मिनट 600 GET अनुरोध। पुनः
            प्रयास करने से पहले `Retry-After` सेकंड तक प्रतीक्षा करें;
            `X-RateLimit-*` हेडर बजट दिखाते हैं।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Rate limited:
                  summary: वर्तमान मिनट का बजट समाप्त हो गया
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
          headers:
            Retry-After:
              description: पुनः प्रयास करने से पहले प्रतीक्षा करने के सेकंड।
              schema:
                type: integer
                minimum: 1
                example: 30
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/events/?limit=50'
            \
              -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.sessions.list_events(
                "11111111-2222-3333-4444-555555555555",
            ):
                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.sessions.listEvents("11111111-2222-3333-4444-555555555555")) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.Sessions.ListEventsAutoPaging(ctx, \"11111111-2222-3333-4444-555555555555\", didit.SessionsListEventsParams{})\nfor iter.Next() {\n\tfmt.Printf(\"%+v\\n\", iter.Current())\n}\nif err := iter.Err(); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            for (var item :
            client.sessions().listEvents("11111111-2222-3333-4444-555555555555"))
            {
                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->sessions->listEvents('11111111-2222-3333-4444-555555555555')
            as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: >-
            require "didit"


            # Reads DIDIT_API_KEY.

            didit = Didit::Client.new


            didit.sessions.list_events("11111111-2222-3333-4444-555555555555").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.Sessions.ListEventsAsync("11111111-2222-3333-4444-555555555555"))

            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    SessionEvent:
      type: object
      description: सत्यापन सत्र की इवेंट टाइमलाइन की एक प्रविष्टि।
      required:
        - uuid
        - event_type
        - created_at
        - component
        - feature_step
        - step
        - details
        - ip_address
        - user_agent
        - device_info
        - file_url
        - sent_at
      properties:
        uuid:
          type: string
          format: uuid
          description: इवेंट पहचानकर्ता।
        event_type:
          type: string
          enum:
            - SESSION_CREATED
            - SESSION_COMPLETED
            - SESSION_STATUS_CHANGED
            - LINK_OPENED
            - FORM_SUBMITTED
            - BUTTON_CLICKED
            - FILE_UPLOADED
            - ATTEMPT_FAILED
            - FEATURE_STEP_CHANGED
            - STEP_RENDERED
            - NOTE_ADDED
            - MANUAL_REVIEW_STARTED
            - WORKFLOW_BRANCH_EVALUATED
            - WORKFLOW_STATUS_NODE_REACHED
            - LOG
          description: >-
            क्या हुआ। होस्टेड फ़्लो या SDK के दौरान डिवाइस द्वारा रिपोर्ट किया
            गया: `LINK_OPENED`, `STEP_RENDERED`, `BUTTON_CLICKED`,
            `FORM_SUBMITTED`, `FILE_UPLOADED`, `ATTEMPT_FAILED` और `LOG`
            (डीबगिंग)। सर्वर द्वारा रिकॉर्ड किया गया: `SESSION_CREATED`,
            `SESSION_STATUS_CHANGED` (`details.old_status`,
            `details.current_status`), `FEATURE_STEP_CHANGED`
            (`details.old_feature_step`, `details.current_feature_step`),
            `WORKFLOW_BRANCH_EVALUATED` और `WORKFLOW_STATUS_NODE_REACHED`
            (वर्कफ़्लो रूटिंग ट्रेस)। पुराने सत्रों में `SESSION_COMPLETED`,
            `NOTE_ADDED` और `MANUAL_REVIEW_STARTED` दिखाई दे सकते हैं।
        created_at:
          type: string
          format: date-time
          description: >-
            Didit ने इवेंट को कब संग्रहीत किया। इवेंट्स को एसिंक्रोनस रूप से,
            `sent_at` के कुछ सेकंड बाद संग्रहीत किया जाता है।
        component:
          type: string
          nullable: true
          description: UI घटक जिसने इवेंट की रिपोर्ट की (केवल डिवाइस इवेंट)।
        feature_step:
          type: string
          nullable: true
          enum:
            - OCR
            - OCR_BACK
            - NFC
            - AML
            - FACE
            - LIVENESS
            - FACE_MATCH
            - IP_ANALYSIS
            - AGE_ESTIMATION
            - PROOF_OF_ADDRESS
            - PHONE_VERIFICATION
            - EMAIL_VERIFICATION
            - FACE_SEARCH
            - DATABASE_VALIDATION
            - QUESTIONNAIRE
            - KYB_REGISTRY
            - KYB_DOCUMENTS
            - KYB_KEY_PEOPLE
            - DOCUMENT_AI
            - GEOLOCATION
            - null
          description: वह सत्यापन सुविधा जिस पर सत्र तब था जब इवेंट घटित हुआ।
        step:
          type: string
          nullable: true
          description: >-
            सुविधा के भीतर स्क्रीन, उदाहरण के लिए `DOCUMENT_CAPTURE_FRONT` या
            `FACE_PASSIVE_LIVENESS`।
        details:
          type: object
          nullable: true
          additionalProperties: true
          description: इवेंट-विशिष्ट डेटा। कुंजियाँ `event_type` पर निर्भर करती हैं।
        ip_address:
          type: string
          nullable: true
          description: >-
            वह IP पता जिससे डिवाइस ने इवेंट की रिपोर्ट की थी। सर्वर द्वारा
            रिकॉर्ड किए गए इवेंट के लिए `null`।
        user_agent:
          type: string
          nullable: true
          description: >-
            डिवाइस का यूज़र एजेंट। सर्वर द्वारा रिकॉर्ड किए गए इवेंट के लिए
            `null`।
        device_info:
          type: object
          nullable: true
          additionalProperties: true
          description: SDK या ब्राउज़र द्वारा रिपोर्ट किए गए डिवाइस विवरण।
        file_url:
          type: string
          format: uri
          nullable: true
          description: >-
            इवेंट से जुड़ी फ़ाइल (उदाहरण के लिए एक कैप्चर की गई छवि) का
            अल्पकालिक प्रीसाइन्ड लिंक। कोई फ़ाइल न होने पर `null`, और बिना
            `media: read` वाली स्कोप्ड API कुंजी के लिए हमेशा `null`।
        sent_at:
          type: integer
          format: int64
          description: >-
            जब इवेंट हुआ था, मिलीसेकंड में Unix टाइमस्टैम्प के रूप में। परिणाम
            इसके अनुसार क्रमित होते हैं।
  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.