> ## 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 एक इमेज से मास्क, प्रिंट, रीप्ले, डीपफ़ेक पकड़ती है। पूरी तरह पैसिव, 2s से कम इंफ़रेंस, प्रति उपयोग भुगतान, कोई मासिक न्यूनतम नहीं।



## OpenAPI

````yaml hi/openapi-25.json POST /v3/passive-liveness/
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/passive-liveness/:
    post:
      tags:
        - Standalone APIs
      summary: निष्क्रिय लाइवनेस
      description: >-
        एक ही चेहरे की छवि से प्रेज़ेंटेशन अटैक — प्रिंटेड फ़ोटो, स्क्रीन
        रीप्ले, मास्क, डीपफ़ेक — का पता लगाएं। किसी वीडियो, गति या उपयोगकर्ता
        इंटरैक्शन की आवश्यकता नहीं है।


        **यह कैसे काम करता है।** छवि का एक बायोमेट्रिक मॉडल द्वारा विश्लेषण किया
        जाता है; सबसे बड़े पहचाने गए चेहरे का मूल्यांकन किया जाता है और एक
        लाइवनेस `score` (0–100) की गणना की जाती है। जब कोई `error`-गंभीरता वाली
        चेतावनी ट्रिगर होती है, तो `status` बदलकर `Declined` हो जाता है:

        - `NO_FACE_DETECTED` — लाइवनेस मॉडल को कोई चेहरा नहीं मिला,

        - `LOW_LIVENESS_SCORE` — स्कोर `face_liveness_score_decline_threshold`
        (डिफ़ॉल्ट `30`) पर या उससे कम है,

        - `LIVENESS_FACE_ATTACK` — मॉडल ने प्रेज़ेंटेशन अटैक का पता लगाया,

        - `FACE_IN_BLOCKLIST` / `POSSIBLE_FACE_IN_BLOCKLIST` — चेहरा आपकी फ़ेस
        ब्लॉकलिस्ट की किसी प्रविष्टि से मेल खाता है।


        `MULTIPLE_FACES_DETECTED` एक `warning`-गंभीरता वाला सिग्नल है (यह
        अस्वीकृत नहीं करता है), और `DUPLICATED_FACE` /
        `POSSIBLE_DUPLICATED_FACE` `information`-गंभीरता वाले सिग्नल हैं जो
        दर्शाते हैं कि वही चेहरा पहले से ही किसी अन्य स्वीकृत सत्र में दिखाई
        दिया था (वे कभी अस्वीकृत नहीं करते हैं)। `face_quality` और
        `face_luminance` (0–100, null हो सकने वाले) कैप्चर गुणवत्ता का वर्णन
        करते हैं।


        **ब्लॉकलिस्ट और डुप्लिकेट स्क्रीनिंग।** **प्रत्येक** कॉल पर चलती है —
        `save_api_request` के साथ या उसके बिना — पहचाने गए चेहरे का आपके
        एप्लिकेशन के चेहरा खोज इंडेक्स से मिलान करके। समान `vendor_data` वाले
        पूर्व चेहरों को पूरे इंडेक्स सर्च से बाहर रखा जाता है — इसलिए एक ही
        उपयोगकर्ता के लिए लाइवनेस फिर से चलाने पर `DUPLICATED_FACE` ट्रिगर नहीं
        होता है, और कॉलर के अपने `vendor_data` वाले सत्र से उत्पन्न ब्लॉकलिस्टेड
        चेहरे को भी फ़्लैग नहीं किया जाता है (समान-`vendor_data` वाले चेहरों के
        लिए `FACE_IN_BLOCKLIST` स्क्रीनिंग को बायपास कर दिया जाता है)।


        **बिलिंग।** प्रत्येक `200` रिस्पॉन्स एक Passive Liveness API क्रेडिट की
        खपत करता है (आपके प्लान क्रेडिट या टॉप अप बैलेंस से भुगतान किया जाता
        है)। अपर्याप्त बैलेंस होने पर किसी भी छवि प्रोसेसिंग से पहले `403`
        रिटर्न होता है।


        **सत्र का स्थायित्व और चेहरे का नामांकन (`save_api_request`, डिफ़ॉल्ट
        `true`)।** जब `true` होता है, तो कॉल को API-प्रकार के सत्र के रूप में
        सुरक्षित रखा जाता है (Business Console, लौटाए गए `request_id` के माध्यम
        से `GET /v3/session/{sessionId}/decision/`, `status.updated` webhook),
        संदर्भ छवि और फ़ेस क्रॉप संग्रहीत किए जाते हैं, और पहचाने गए चेहरे को
        **आपके चेहरा खोज इंडेक्स में नामांकित किया जाता है** ताकि बाद के चेहरा
        खोज कॉल और डुप्लिकेट जांच इसका मिलान कर सकें। जब `false` होता है, तो कॉल
        वन-शॉट होती है: कुछ भी संग्रहीत नहीं किया जाता है और चेहरे को नामांकित
        नहीं किया जाता है (ब्लॉकलिस्ट/डुप्लिकेट स्क्रीनिंग अभी भी चलती है)।


        **सैंडबॉक्स।** सैंडबॉक्स API कुंजियाँ सभी प्रोसेसिंग और बिलिंग को छोड़
        देती हैं: अनुरोध सत्यापन के बाद (गलत इनपुट अभी भी `400` लौटाता है),
        endpoint एक स्थिर `Approved` मॉक payload लौटाता है, कोई सत्र सुरक्षित
        नहीं रखा जाता है, और कोई क्रेडिट खपत नहीं होता है।


        **प्रमाणीकरण।** अपने एप्लिकेशन की API कुंजी `x-api-key` हेडर में भेजें।
        अनुपलब्ध या अमान्य क्रेडेंशियल्स `403` (`{"detail": "You do not have
        permission to perform this action."}`) लौटाते हैं — यह API कभी भी `401`
        नहीं लौटाती है।


        **रेट लिमिट।** सभी POST/PATCH/DELETE endpoints पर प्रति API कुंजी 300
        अनुरोध/मिनट का साझा राइट बजट; इसे पार करने पर `429` रिटर्न होता है।
      operationId: post_v3passive-liveness
      parameters: []
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required:
                - user_image
              properties:
                user_image:
                  type: string
                  format: binary
                  description: >-
                    सामने की ओर चेहरे की इमेज (उदा. सेल्फ़ी)। स्वीकृत एक्सटेंशन:
                    `tiff`, `jpg`, `jpeg`, `png`, `webp`। अधिकतम अपलोड आकार: **5
                    MB** (फ़ाइलें इससे बड़ी होने पर `400` के साथ अस्वीकृत कर दी
                    जाती हैं)। प्रोसेसिंग से पहले इमेज स्वचालित रूप से ~0.5 MB
                    तक कंप्रेस की जाती हैं, इसलिए बहुत उच्च रिज़ॉल्यूशन सटीकता
                    में सुधार नहीं करते हैं। इमेज में एक ही व्यक्ति होना चाहिए —
                    जब कई चेहरे मौजूद होते हैं, तो सबसे बड़े चेहरे का मूल्यांकन
                    किया जाता है और `MULTIPLE_FACES_DETECTED` चेतावनी जोड़ी जाती
                    है।
                face_liveness_score_decline_threshold:
                  type: number
                  format: float
                  default: 30
                  minimum: 0
                  maximum: 100
                  description: >-
                    लाइवनेस स्कोर थ्रेशोल्ड (0–100)। इस मान **पर या उससे नीचे**
                    का परिकलित स्कोर `LOW_LIVENESS_SCORE` चेतावनी जारी करता है
                    और `status` को `Declined` पर सेट करता है। डिफ़ॉल्ट `30`;
                    अधिक सख्त एंटी-स्पूफिंग स्थिति के लिए इसे बढ़ाएं। 0–100 से
                    बाहर के मान `400` लौटाते हैं।
                  example: 30
                rotate_image:
                  type: boolean
                  default: false
                  description: >-
                    जब `true` होता है, तो सेवा इनपुट के 90-डिग्री घुमावों का
                    प्रयास करती है और उस ओरिएंटेशन का उपयोग करती है जिससे सबसे
                    अच्छा फ़ेस डिटेक्शन प्राप्त होता है। तब उपयोगी होता है जब
                    EXIF ओरिएंटेशन गायब हो। विलंबता जोड़ता है।
                  example: false
                save_api_request:
                  type: boolean
                  default: true
                  description: >-
                    जब `true` (डिफ़ॉल्ट) होता है, तो कॉल को API-प्रकार के सत्र
                    के रूप में सुरक्षित रखा जाता है, फ़ेस छवियों को संग्रहीत
                    किया जाता है, `status.updated` webhook उत्सर्जित किया जाता
                    है, और पहचानी गई फ़ेस को आपके चेहरा खोज इंडेक्स में नामांकित
                    किया जाता है। जब `false` होता है, तो कॉल वन-शॉट होती है —
                    कुछ भी संग्रहीत नहीं किया जाता है और चेहरा नामांकित नहीं
                    होता है। ब्लॉकलिस्ट और डुप्लिकेट स्क्रीनिंग दोनों ही मामलों
                    में चलती हैं।
                  example: true
                vendor_data:
                  type: string
                  description: >-
                    वैकल्पिक अपारदर्शी पहचानकर्ता (आपकी उपयोगकर्ता ID, ईमेल,
                    UUID…) जो स्थायी सत्र पर संग्रहीत होता है और वापस भेजा जाता
                    है। इसका उपयोग डुप्लिकेट-चेहरा जांच से उसी `vendor_data`
                    वाले पूर्व सत्रों को बाहर करने के लिए भी किया जाता है, ताकि
                    उसी उपयोगकर्ता को पुनः सत्यापित करने पर `DUPLICATED_FACE` न
                    उठे।
                  example: user-123
                metadata:
                  type: object
                  additionalProperties: true
                  description: >-
                    सत्र के साथ संग्रहीत (जब `save_api_request=true`) और वापस
                    लौटाया जाने वाला वैकल्पिक JSON ऑब्जेक्ट। मल्टीपार्ट अनुरोधों
                    में, इसे JSON-एन्कोडेड स्ट्रिंग फ़ील्ड के रूप में भेजें —
                    इसे एक ऑब्जेक्ट में पार्स किया जाता है।
                  example:
                    flow: withdrawal
            example:
              user_image: (binary JPEG/PNG selfie)
              face_liveness_score_decline_threshold: 30
              rotate_image: false
              save_api_request: true
              vendor_data: user-123
              metadata:
                flow: withdrawal
      responses:
        '200':
          description: >-
            निष्क्रिय लाइवनेस पूर्ण हुई। `liveness.score` मॉडल का 0–100 विश्वास
            स्कोर है कि छवि एक जीवित व्यक्ति को दर्शाती है; `status` `Approved`
            है जब तक कि `error`-गंभीरता वाली चेतावनी ट्रिगर न हुई हो। एक स्पूफ़
            किया गया या ब्लॉकलिस्ट किया गया चेहरा अभी भी `200` लौटाता है — केवल
            HTTP कोड ही नहीं, बल्कि `liveness.status` और `liveness.warnings` की
            भी जांच करें। जब `save_api_request=true` होता है, तो `request_id`
            संरक्षित सत्र आईडी होती है।
          content:
            application/json:
              examples:
                Approved:
                  summary: लाइव चेहरा — कोई चेतावनी नहीं
                  value:
                    request_id: a1b2c3d4-e5f6-7890-1234-567890abcdef
                    liveness:
                      status: Approved
                      method: PASSIVE
                      score: 95
                      user_image:
                        entities:
                          - bbox:
                              - 661
                              - 728
                              - 1688
                              - 2188
                            confidence: 0.732973
                            age: 26.91
                            gender: male
                            race: null
                        best_angle: 0
                      warnings: []
                      face_quality: 84.21
                      face_luminance: 50.33
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T01:04:42.763237+00:00'
                Declined - presentation attack:
                  summary: मॉडल ने स्पूफ (प्रिंट, रीप्ले, मास्क…) को फ़्लैग किया
                  value:
                    request_id: f1c8c9b2-d3e4-4f5a-9b8c-7d6e5f4a3b2c
                    liveness:
                      status: Declined
                      method: PASSIVE
                      score: 12.5
                      user_image:
                        entities:
                          - bbox:
                              - 100
                              - 120
                              - 420
                              - 540
                            confidence: 0.81
                            age: 30.1
                            gender: female
                            race: null
                        best_angle: 0
                      warnings:
                        - risk: LOW_LIVENESS_SCORE
                          feature: LIVENESS
                          additional_data: null
                          log_type: error
                          short_description: Low liveness score
                          long_description: >-
                            The liveness check resulted in a low score,
                            indicating potential use of non-live facial
                            representations or poor-quality biometric data.
                        - risk: LIVENESS_FACE_ATTACK
                          feature: LIVENESS
                          additional_data: null
                          log_type: error
                          short_description: Liveness Face Attack
                          long_description: >-
                            The system detected a potential attempt to bypass
                            the liveness check.
                      face_quality: 72.4
                      face_luminance: 48.2
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T01:04:42.763237+00:00'
                Declined - face on blocklist:
                  summary: लाइव चेहरा, लेकिन यह ब्लॉकलिस्ट प्रविष्टि से मेल खाता है
                  value:
                    request_id: 0b54a1de-22aa-4e0f-9c84-5a2b1f3c4d5e
                    liveness:
                      status: Declined
                      method: PASSIVE
                      score: 93.75
                      user_image:
                        entities:
                          - bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.722082
                            age: 27
                            gender: male
                            race: null
                        best_angle: 0
                      warnings:
                        - risk: FACE_IN_BLOCKLIST
                          feature: LIVENESS
                          additional_data:
                            blocklisted_session_id: 882c42d5-8a4d-4d20-8080-a22f57822c86
                            blocklisted_session_number: 3242
                            api_service: null
                          log_type: error
                          short_description: Face in blocklist
                          long_description: >-
                            The system identified a face in the blocklist, which
                            means the face is not allowed to be verified.
                      face_quality: null
                      face_luminance: null
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T01:04:42.763237+00:00'
              schema:
                type: object
                properties:
                  request_id:
                    type: string
                    format: uuid
                    description: >-
                      `save_api_request=true` होने पर सहेजी गई सत्र ID (`GET
                      /v3/session/{sessionId}/decision/` के साथ उपयोग योग्य);
                      अन्यथा एक क्षणिक सहसंबंध UUID।
                  liveness:
                    type: object
                    properties:
                      status:
                        type: string
                        enum:
                          - Approved
                          - Declined
                        description: >-
                          `Declined` जब कम से कम एक `error`-गंभीरता वाली चेतावनी
                          ट्रिगर हुई हो (कोई चेहरा नहीं, कम स्कोर, प्रेज़ेंटेशन
                          अटैक, या कोई ब्लॉकलिस्ट हिट); अन्यथा `Approved`।
                          `warning`/`information` प्रविष्टियाँ (एकाधिक चेहरे,
                          डुप्लिकेट) अपने आप कभी अस्वीकृत नहीं करती हैं।
                      method:
                        type: string
                        enum:
                          - PASSIVE
                        description: इस endpoint के लिए हमेशा `PASSIVE`।
                      score:
                        type: number
                        format: float
                        nullable: true
                        minimum: 0
                        maximum: 100
                        description: >-
                          लाइवनेस विश्वास (0–100, दो दशमलव) कि छवि स्पूफिंग के
                          बजाय एक जीवित व्यक्ति को दर्शाती है। जब मॉडल ने कोई
                          विश्वास नहीं लौटाया तो `null`।
                        example: 95
                      user_image:
                        type: object
                        description: सबमिट की गई छवि के लिए चेहरा-पहचान परिणाम।
                        properties:
                          entities:
                            type: array
                            items:
                              type: object
                              properties:
                                bbox:
                                  type: array
                                  items:
                                    type: integer
                                  minItems: 4
                                  maxItems: 4
                                  description: >-
                                    प्रोसेस की गई छवि में `[x_min, y_min, x_max,
                                    y_max]` पिक्सेल निर्देशांक के रूप में पहचाने
                                    गए चेहरे का बाउंडिंग बॉक्स।
                                  example:
                                    - 661
                                    - 728
                                    - 1688
                                    - 2188
                                confidence:
                                  type: number
                                  format: float
                                  minimum: 0
                                  maximum: 1
                                  description: चेहरा-पहचान विश्वास (0–1)।
                                  example: 0.732973
                                age:
                                  type: number
                                  format: float
                                  description: >-
                                    पहचाने गए चेहरे की मॉडल-अनुमानित आयु, वर्षों
                                    में। केवल सूचनात्मक — यह लाइवनेस निर्णय को
                                    प्रभावित नहीं करती है।
                                  example: 26.91
                                gender:
                                  type: string
                                  description: >-
                                    पहचाने गए चेहरे का मॉडल-अनुमानित लिंग
                                    (`male` या `female`)। केवल सूचनात्मक।
                                  example: male
                                race:
                                  type: string
                                  nullable: true
                                  description: >-
                                    आरक्षित फ़ील्ड — इस endpoint से मिलने वाले
                                    रिस्पॉन्स में हमेशा `null` होता है।
                                  example: null
                            description: >-
                              प्रत्येक पहचाने गए चेहरे के लिए एक प्रविष्टि। सबसे
                              बड़े चेहरे का मूल्यांकन किया जाता है।
                          best_angle:
                            type: integer
                            nullable: true
                            description: >-
                              रोटेशन (डिग्री) जिसने चेहरे का सर्वोत्तम डिटेक्शन
                              उत्पन्न किया; केवल तभी गैर-शून्य जब
                              `rotate_image=true` ने ओरिएंटेशन को ठीक किया।
                            example: 0
                      warnings:
                        type: array
                        description: >-
                          जोखिम सिग्नल। `error` गंभीरता (अस्वीकृति):
                          `NO_FACE_DETECTED`, `LOW_LIVENESS_SCORE` (स्कोर
                          थ्रेशोल्ड पर या उससे नीचे), `LIVENESS_FACE_ATTACK`,
                          `FACE_IN_BLOCKLIST`, `POSSIBLE_FACE_IN_BLOCKLIST`।
                          `warning` गंभीरता (समीक्षा, कोई अस्वीकृति नहीं):
                          `MULTIPLE_FACES_DETECTED`। `information` गंभीरता (कोई
                          अस्वीकृति नहीं): `DUPLICATED_FACE`,
                          `POSSIBLE_DUPLICATED_FACE` — वही चेहरा पहले ही किसी
                          अन्य स्वीकृत सत्र में दिखाई दे चुका है।
                        items:
                          type: object
                          properties:
                            risk:
                              type: string
                              enum:
                                - NO_FACE_DETECTED
                                - LOW_LIVENESS_SCORE
                                - LIVENESS_FACE_ATTACK
                                - MULTIPLE_FACES_DETECTED
                                - FACE_IN_BLOCKLIST
                                - POSSIBLE_FACE_IN_BLOCKLIST
                                - DUPLICATED_FACE
                                - POSSIBLE_DUPLICATED_FACE
                              description: मशीन-पठनीय जोखिम कोड।
                            feature:
                              type: string
                              enum:
                                - LIVENESS
                              description: >-
                                सुविधा जिसने चेतावनी उत्पन्न की। इस endpoint पर
                                हमेशा `LIVENESS`।
                            additional_data:
                              type: object
                              nullable: true
                              additionalProperties: true
                              description: >-
                                अधिकांश चेतावनियों के लिए `null`। ब्लॉकलिस्ट
                                हिट्स में `{blocklisted_session_id,
                                blocklisted_session_number, api_service}` शामिल
                                होते हैं; डुप्लिकेट हिट्स में
                                `{duplicated_session_id,
                                duplicated_session_number, api_service}` शामिल
                                होते हैं जो मिलान वाले सत्र की ओर संकेत करते
                                हैं।
                            log_type:
                              type: string
                              enum:
                                - error
                                - warning
                                - information
                              description: >-
                                गंभीरता। `error` चेतावनियाँ `status` को
                                `Declined` में बदल देती हैं; `warning` और
                                `information` प्रविष्टियाँ केवल सलाहकारी होती
                                हैं और अपने आप कभी अस्वीकृत नहीं करती हैं।
                            short_description:
                              type: string
                              description: जोखिम का मानव-पठनीय एक पंक्ति का सारांश।
                            long_description:
                              type: string
                              description: जोखिम का मानव-पठनीय स्पष्टीकरण।
                      face_quality:
                        type: number
                        format: float
                        nullable: true
                        minimum: 0
                        maximum: 100
                        description: >-
                          डिटेक्ट किए गए चेहरे का कैप्चर-गुणवत्ता स्कोर, 0–100
                          में सामान्यीकृत। जब मॉडल विश्वसनीय मान उत्पन्न नहीं कर
                          सका तो `null`।
                        example: 84.21
                      face_luminance:
                        type: number
                        format: float
                        nullable: true
                        minimum: 0
                        maximum: 100
                        description: >-
                          पहचाने गए चेहरे की चमक (brightness), 0–100 में
                          सामान्यीकृत। अनुपलब्ध होने पर `null`।
                        example: 50.33
                  vendor_data:
                    type: string
                    nullable: true
                    description: आपके द्वारा भेजे गए `vendor_data` का इको, या `null`।
                  metadata:
                    type: object
                    nullable: true
                    additionalProperties: true
                    description: आपके द्वारा भेजे गए `metadata` ऑब्जेक्ट का इको, या `null`।
                  created_at:
                    type: string
                    format: date-time
                    description: >-
                      रिस्पॉन्स जनरेट होने का ISO 8601 टाइमस्टैम्प (UTC), उदा.
                      `2026-06-12T01:04:42.763237+00:00`।
        '400':
          description: >-
            सत्यापन त्रुटि। तब लौटाई जाती है जब `user_image` गायब हो, 5 MB से
            अधिक हो, इसका एक्सटेंशन असमर्थित हो, सर्वर-साइड इमेज डिकोडिंग विफल
            हो जाए, या जब कोई विकल्प सीमा से बाहर हो। फ़ील्ड त्रुटियां DRF के
            `{field: [messages]}` एनवेलप का उपयोग करती हैं; इमेज-डिकोडिंग
            विफलताएं `{"error": ...}` का उपयोग करती हैं।
          content:
            application/json:
              examples:
                Missing image:
                  summary: '`user_image` फ़ॉर्म डेटा में शामिल नहीं है'
                  value:
                    user_image:
                      - No file was submitted.
                Invalid image format:
                  summary: स्वीकृत एक्सटेंशन लेकिन अनडीकोडेबल इमेज सामग्री
                  value:
                    error: Invalid user image format.
                    code: invalid_image
                Unsupported file extension:
                  summary: फ़ाइल एक्सटेंशन tiff/jpg/jpeg/png/webp से बाहर है
                  value:
                    user_image:
                      - >-
                        File extension “txt” is not allowed. Allowed extensions
                        are: tiff, jpg, jpeg, png, webp.
                File too large:
                  summary: अपलोड 5 MB की सीमा से अधिक है
                  value:
                    user_image:
                      - File size should not exceed 5 MB
        '403':
          description: >-
            अनुमति अस्वीकृत। तब लौटाया जाता है जब `x-api-key` हेडर अनुपलब्ध हो,
            और तब भी जब कॉल करने वाले संगठन का बैलेंस कॉल को कवर नहीं कर सकता;
            गलत, निरस्त या समय-सीमा समाप्त कुंजी `401` लौटाती है। अनुपलब्ध कुंजी
            `{"detail": ...}` के साथ `403` लौटाती है; गलत, निरस्त या समय-सीमा
            समाप्त कुंजी `401` लौटाती है। क्रेडिट की कमी किसी भी इमेज प्रोसेसिंग
            से पहले `{"error": ...}` के साथ `403` लौटाती है।
          content:
            application/json:
              examples:
                Missing or invalid API key:
                  summary: कोई `x-api-key` हेडर नहीं, या कुंजी अमान्य/निरस्त है
                  value:
                    detail: You do not have permission to perform this action.
                Not enough credits:
                  summary: संगठन का बैलेंस कॉल को कवर नहीं कर सकता
                  value:
                    error: >-
                      You don't have enough credits to perform this request.
                      Please top up at https://business.didit.me
        '429':
          description: >-
            रेट लिमिट पार हो गई। POST/PATCH/DELETE endpoints प्रति मिनट प्रति
            API कुंजी 300 राइट अनुरोधों का बजट साझा करते हैं (लेन-देन निर्माण और
            इवेंट इनजेशन का 600 का एक अलग बजट है)। रिस्पॉन्स में
            `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset` और
            `Retry-After` हेडर होते हैं।
          content:
            application/json:
              examples:
                Write rate limit exceeded:
                  summary: वर्तमान मिनट में 300 से अधिक राइट अनुरोध
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
              schema:
                type: object
                properties:
                  detail:
                    type: string
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl -X POST 'https://verification.didit.me/v3/passive-liveness/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -F 'user_image=@./selfie.jpg' \
              -F 'face_liveness_score_decline_threshold=30' \
              -F 'save_api_request=true' \
              -F 'vendor_data=user-123'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.passive_liveness.check(
                user_image=open("user_image.jpg", "rb"),
                face_liveness_score_decline_threshold=30.0,
                rotate_image=False,
                save_api_request=True,
                vendor_data="user-123",
                metadata={"flow": "withdrawal"},
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit, { fileFromPath } from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            const result = await didit.passiveLiveness.check({
              user_image: await fileFromPath("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "withdrawal" },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.PassiveLiveness.Check(ctx, didit.PassiveLivenessCheckParams{\n\tUserImage:                         didit.FileFromPath(\"user_image.jpg\"),\n\tFaceLivenessScoreDeclineThreshold: didit.Float(30.0),\n\tRotateImage:                       didit.Bool(false),\n\tSaveAPIRequest:                    didit.Bool(true),\n\tVendorData:                        didit.String(\"user-123\"),\n\tMetadata:                          didit.Some(map[string]any{\"flow\": \"withdrawal\"}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.nio.file.Path;

            import java.util.Map;

            import me.didit.Didit;

            import me.didit.types.PassiveLivenessCheckParams;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.passiveLiveness().check(PassiveLivenessCheckParams.builder()
                    .userImage(Path.of("user_image.jpg"))
                    .faceLivenessScoreDeclineThreshold(30.0)
                    .rotateImage(false)
                    .saveApiRequest(true)
                    .vendorData("user-123")
                    .metadata(Map.of("flow", "withdrawal"))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;
            use Didit\File;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            $result = $didit->passiveLiveness->check([
                'user_image' => File::fromPath('user_image.jpg'),
                'face_liveness_score_decline_threshold' => 30.0,
                'rotate_image' => false,
                'save_api_request' => true,
                'vendor_data' => 'user-123',
                'metadata' => ['flow' => 'withdrawal'],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.passive_liveness.check(
              user_image: Pathname("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "withdrawal" }
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.PassiveLiveness.CheckAsync(new
            PassiveLivenessCheckParams

            {
                UserImage = FileUpload.FromPath("user_image.jpg"),
                FaceLivenessScoreDeclineThreshold = 30.0,
                RotateImage = false,
                SaveApiRequest = true,
                VendorData = "user-123",
                Metadata = new Dictionary<string, object> { ["flow"] = "withdrawal" },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  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.