> ## 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: POST /v3/age-estimation/ से बिना ID के AI आधारित आयु जाँच, पैसिव लाइवनेस और sub-2s अनुमान, प्रति उपयोग मूल्य पर।



## OpenAPI

````yaml hi/openapi-25.json POST /v3/age-estimation/
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/age-estimation/:
    post:
      tags:
        - Standalone APIs
      summary: आयु अनुमान (चेहरे की आयु + पैसिव लाइवनेस)
      description: >-
        एक ही चेहरे के फ़ोटो से किसी व्यक्ति की आयु का अनुमान लगाएँ और उसी कॉल
        में पैसिव लाइवनेस जाँच चलाएँ — यह मॉडल द्वारा अनुमानित `age_estimation`
        (वर्षों में), एक लाइवनेस `score` (0–100), और एक `Approved`/`Declined`
        `status` लौटाता है। आयु **चेहरे से मॉडल द्वारा अनुमानित होती है, किसी
        दस्तावेज़ से सत्यापित नहीं** — इसका उपयोग आयु प्रतिबंधों और कम रुकावट
        वाली जाँचों के लिए करें, आयु के कानूनी प्रमाण के रूप में नहीं।


        **यह कैसे काम करता है।** चेहरों का पता लगाने के लिए छवि का विश्लेषण किया
        जाता है (यदि कैप्चर तिरछा या उल्टा हो सकता है तो `rotate_image=true` सेट
        करें); प्रत्येक पाए गए चेहरे की एक अनुमानित आयु प्राप्त होती है, और
        फ्रेम में सबसे बड़ा चेहरा `age_estimation` निर्धारित करता है। समानांतर
        में, एक पैसिव लाइवनेस मॉडल स्कोर करता है कि क्या फ़ोटो किसी जीवित
        व्यक्ति को दिखाती है (उपयोगकर्ता से किसी चुनौती की आवश्यकता नहीं होती)
        और प्रेज़ेंटेशन अटैक (फ़ोटो की फ़ोटो, स्क्रीन, मास्क) का पता लगाता है।
        सर्वोत्तम परिणामों के लिए प्रति छवि एक स्पष्ट, सामने की ओर मुख वाला,
        अच्छी रोशनी वाला चेहरा सबमिट करें।


        **निर्णय तर्क।** कोई भी चेतावनी अस्वीकृति का कारण बनती है: `status` केवल
        तभी `Approved` होता है जब `warnings` सरणी खाली होती है।
        `face_liveness_score_decline_threshold` (डिफ़ॉल्ट `30`) पर या उससे कम का
        लाइवनेस `score` `LOW_LIVENESS_SCORE` जोड़ता है; पता लगाया गया हमला
        `LIVENESS_FACE_ATTACK` जोड़ता है; लाइवनेस मॉडल द्वारा कोई चेहरा न पाए
        जाने पर `NO_FACE_DETECTED` जुड़ता है; चेहरे की अनुमानित आयु न मिलने पर
        `AGE_NOT_DETECTED` जुड़ता है (`age_estimation` `null` है);
        `age_estimation_decline_threshold` (डिफ़ॉल्ट `18`) से कम अनुमानित आयु
        `AGE_BELOW_MINIMUM` जोड़ती है। आपके थ्रेशोल्ड के करीब की सीमांत आयु के
        लिए दस्तावेज़-आधारित सत्यापन पर फ़ॉलबैक करना उचित है — सीमा के करीब के
        चेहरों के लिए मॉडल की त्रुटि बढ़ जाती है।


        **बिलिंग।** प्रत्येक `200` रिस्पॉन्स एक आयु अनुमान API क्रेडिट का उपभोग
        करता है (आपके प्लान क्रेडिट या टॉप-अप बैलेंस से भुगतान किया जाता है)। जब
        संगठन का बैलेंस कॉल को कवर नहीं कर सकता, तो endpoint किसी भी छवि
        प्रोसेसिंग से पहले अपर्याप्त-क्रेडिट त्रुटि के साथ `403` लौटाता है।


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


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


        **प्रमाणीकरण।** अपने एप्लिकेशन की 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_v3age-estimation
      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` (कोई PDF नहीं)। अधिकतम
                    अपलोड आकार: **5 MB** (बड़ी फ़ाइलों को `400` के साथ अस्वीकार
                    कर दिया जाता है)। प्रोसेसिंग से पहले छवियों को स्वचालित रूप
                    से ~0.3 MB तक कंप्रेस किया जाता है, इसलिए बहुत उच्च
                    रिज़ॉल्यूशन सटीकता में सुधार नहीं करते हैं।
                face_liveness_score_decline_threshold:
                  type: number
                  format: float
                  default: 30
                  minimum: 0
                  maximum: 100
                  description: >-
                    लाइवनेस थ्रेशोल्ड (0–100)। इस मान **पर या उससे नीचे** का
                    लाइवनेस `score` `LOW_LIVENESS_SCORE` चेतावनी जोड़ता है और
                    अस्वीकृत करता है। सख्त एंटी-स्पूफिंग के लिए इसे बढ़ाएं;
                    0–100 से बाहर के मान `400` लौटाते हैं।
                  example: 30
                age_estimation_decline_threshold:
                  type: integer
                  default: 18
                  minimum: 0
                  maximum: 100
                  description: >-
                    वर्षों में न्यूनतम स्वीकार्य अनुमानित आयु। इस मान से **कम**
                    अनुमानित आयु `AGE_BELOW_MINIMUM` चेतावनी जोड़ती है और इसे
                    अस्वीकृत कर देती है। आयु जाँच को अक्षम करने के लिए `0` सेट
                    करें (कॉल तब आयु-आधारित निर्णय के बिना केवल लाइवनेस + आयु
                    अनुमान चलाती है)।
                  example: 18
                rotate_image:
                  type: boolean
                  default: false
                  description: >-
                    जब `true` होता है, तो सेवा 90-डिग्री अंतराल (0, 90, 180,
                    270) में इनपुट छवि का प्रयास करती है और उस ओरिएंटेशन का
                    उपयोग करती है जिससे सबसे अच्छा फ़ेस डिटेक्शन प्राप्त होता है
                    — छूटे हुए EXIF ओरिएंटेशन वाले मोबाइल कैप्चर के लिए उपयोगी।
                    विलंबता जोड़ता है, इसलिए इसे केवल तभी सक्षम करें यदि आप सीधी
                    छवियों की गारंटी नहीं दे सकते।
                  example: false
                save_api_request:
                  type: boolean
                  default: true
                  description: >-
                    `true` (डिफ़ॉल्ट) होने पर, कॉल को API-प्रकार के सत्र के रूप
                    में बनाए रखता है — Business Console में दृश्यमान, लौटाए गए
                    `request_id` का उपयोग करके `GET
                    /v3/session/{sessionId}/decision/` के माध्यम से प्राप्त करने
                    योग्य, `status.updated` webhook के माध्यम से घोषित, और
                    पहचाने गए चेहरे को आपके एप्लिकेशन के फ़ेस इंडेक्स में जोड़ा
                    जाता है। `false` होने पर, कुछ भी संग्रहीत नहीं किया जाता है
                    और `request_id` केवल रिस्पॉन्स सहसंबंध के लिए एक अस्थायी
                    UUID होता है।
                  example: true
                vendor_data:
                  type: string
                  description: >-
                    वैकल्पिक अपारदर्शी स्ट्रिंग (आपकी आंतरिक उपयोगकर्ता ID,
                    ईमेल, UUID…) जो स्थायी सत्र पर संग्रहीत होती है और रिस्पॉन्स
                    में वापस भेजी जाती है। इसका उपयोग अपने स्वयं के रिकॉर्ड के
                    साथ API कॉल को सहसंबंधित करने और बाद में सत्रों को फ़िल्टर
                    करने के लिए करें।
                  example: user-123
                metadata:
                  type: object
                  additionalProperties: true
                  description: >-
                    सत्र के साथ संग्रहीत वैकल्पिक JSON ऑब्जेक्ट (जब
                    `save_api_request=true`) और रिस्पॉन्स में वापस प्रतिध्वनित
                    होता है। मल्टीपार्ट अनुरोधों में, इसे JSON-एन्कोडेड स्ट्रिंग
                    फ़ील्ड (उदा. `metadata={"flow":"age-gate"}`) के रूप में
                    भेजें — इसे एक ऑब्जेक्ट में पार्स किया जाता है।
                  example:
                    flow: age-gate
            example:
              user_image: (binary JPEG/PNG of the selfie)
              face_liveness_score_decline_threshold: 30
              age_estimation_decline_threshold: 18
              rotate_image: false
              save_api_request: true
              vendor_data: user-123
              metadata:
                flow: age-gate
      responses:
        '200':
          description: >-
            आयु अनुमान और पैसिव लाइवनेस पूर्ण हो गए।
            `age_estimation.age_estimation` सबसे बड़े पहचाने गए चेहरे की मॉडल
            द्वारा अनुमानित आयु (वर्षों में) है (यदि कोई नहीं है तो `null`);
            `age_estimation.score` पैसिव-लाइवनेस स्कोर (0–100) है; `status` केवल
            तभी `Approved` होता है जब `warnings` खाली हो। कम उम्र या स्पूफ़ किए
            गए कैप्चर पर भी `status: "Declined"` के साथ `200` रिटर्न होता है —
            केवल HTTP कोड ही नहीं, बल्कि बॉडी का भी निरीक्षण करें। जब
            `save_api_request=true` हो, तो `request_id` परसिस्टेड सत्र id होती
            है।
          content:
            application/json:
              examples:
                Approved:
                  summary: लाइव वयस्क चेहरा — दोनों जाँचें पास हुईं
                  value:
                    request_id: 0c40ba43-64ab-4e2e-b4b8-7d1f12f81bc1
                    age_estimation:
                      status: Approved
                      method: PASSIVE
                      score: 97.5
                      user_image:
                        entities:
                          - age: 27.33
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: male
                        best_angle: 0
                      age_estimation: 27.33
                      warnings: []
                    vendor_data: user-123
                    metadata:
                      flow: age-gate
                    created_at: '2026-06-12T02:24:11.512941+00:00'
                Declined - age below threshold:
                  summary: '`age_estimation_decline_threshold` से कम अनुमानित आयु'
                  value:
                    request_id: 9be41a6f-2f4e-4f57-92f4-b3a4f6f0a1c2
                    age_estimation:
                      status: Declined
                      method: PASSIVE
                      score: 95
                      user_image:
                        entities:
                          - age: 16.5
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: female
                        best_angle: 0
                      age_estimation: 16.5
                      warnings:
                        - risk: AGE_BELOW_MINIMUM
                          feature: LIVENESS
                          additional_data: null
                          log_type: error
                          short_description: Age below minimum
                          long_description: >-
                            The age of the face is below the minimum age
                            threshold for the application.
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T02:26:40.118332+00:00'
                Declined - liveness too low:
                  summary: >-
                    अस्वीकृति थ्रेशोल्ड पर या उससे नीचे लाइवनेस स्कोर (संभावित
                    स्पूफिंग)
                  value:
                    request_id: 5f6f2f1f-7c4f-43b9-8d62-0a8f4c2d9e77
                    age_estimation:
                      status: Declined
                      method: PASSIVE
                      score: 5
                      user_image:
                        entities:
                          - age: 25
                            bbox:
                              - 40
                              - 40
                              - 100
                              - 100
                            confidence: 0.7177750468254089
                            gender: male
                        best_angle: 0
                      age_estimation: 25
                      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.
                    vendor_data: user-123
                    metadata: null
                    created_at: '2026-06-12T02:27:02.901547+00:00'
              schema:
                type: object
                properties:
                  request_id:
                    type: string
                    format: uuid
                    description: >-
                      `save_api_request=true` होने पर सहेजी गई सत्र ID (`GET
                      /v3/session/{sessionId}/decision/` के साथ उपयोग योग्य);
                      अन्यथा एक क्षणिक सहसंबंध UUID।
                  age_estimation:
                    type: object
                    properties:
                      status:
                        type: string
                        enum:
                          - Approved
                          - Declined
                        description: >-
                          `Approved` जब कोई चेतावनी जारी नहीं की गई थी; अन्यथा
                          `Declined` (इस endpoint द्वारा उत्पन्न प्रत्येक
                          चेतावनी अस्वीकृति का कारण बनती है)।
                      method:
                        type: string
                        enum:
                          - PASSIVE
                        description: >-
                          लाइवनेस विधि। इस endpoint पर हमेशा `PASSIVE` (एकल-छवि,
                          कोई उपयोगकर्ता चुनौती नहीं)।
                      score:
                        type: number
                        format: float
                        nullable: true
                        minimum: 0
                        maximum: 100
                        description: >-
                          0 से 100 तक निष्क्रिय-लाइवनेस स्कोर — मॉडल का यह
                          विश्वास स्कोर कि फ़ोटो एक जीवित व्यक्ति को दर्शाती है।
                          `face_liveness_score_decline_threshold` के विरुद्ध
                          तुलना की जाती है; इस पर या इससे नीचे कॉल
                          `LOW_LIVENESS_SCORE` के साथ अस्वीकृत हो जाती है। जब
                          लाइवनेस मॉडल कोई विश्वास वापस नहीं करता है तो `null`
                          होता है — कॉल फिर भी `LOW_LIVENESS_SCORE` के साथ
                          अस्वीकृत हो जाती है क्योंकि थ्रेशोल्ड तुलना के लिए
                          null को 0 माना जाता है।
                        example: 97.5
                      user_image:
                        type: object
                        description: विश्लेषित छवि के लिए चेहरा-पहचान परिणाम।
                        properties:
                          entities:
                            type: array
                            description: >-
                              प्रत्येक पहचाने गए चेहरे के लिए एक प्रविष्टि। कोई
                              चेहरा न मिलने पर खाली (फिर `age_estimation` `null`
                              होता है और एक `AGE_NOT_DETECTED` चेतावनी जोड़ी
                              जाती है)।
                            items:
                              type: object
                              properties:
                                age:
                                  type: number
                                  format: float
                                  description: इस चेहरे की मॉडल-अनुमानित आयु, वर्षों में।
                                  example: 27.33
                                bbox:
                                  type: array
                                  items:
                                    type: integer
                                  minItems: 4
                                  maxItems: 4
                                  description: >-
                                    प्रोसेस की गई छवि में `[x_min, y_min, x_max,
                                    y_max]` पिक्सेल निर्देशांक के रूप में पहचाने
                                    गए चेहरे का बाउंडिंग बॉक्स।
                                  example:
                                    - 40
                                    - 40
                                    - 100
                                    - 100
                                confidence:
                                  type: number
                                  format: float
                                  minimum: 0
                                  maximum: 1
                                  description: चेहरा-पहचान विश्वास (0–1)।
                                  example: 0.7177750468254089
                                gender:
                                  type: string
                                  description: >-
                                    पहचाने गए चेहरे का मॉडल-अनुमानित लिंग
                                    (`male` या `female`)। केवल सूचनात्मक।
                                  example: male
                          best_angle:
                            type: integer
                            nullable: true
                            description: >-
                              रोटेशन (डिग्री: 0, 90, 180, या 270) जिसने चेहरे का
                              सर्वोत्तम डिटेक्शन उत्पन्न किया। केवल तभी
                              गैर-शून्य जब `rotate_image=true` ने ओरिएंटेशन को
                              ठीक किया।
                            example: 0
                      age_estimation:
                        type: number
                        format: float
                        nullable: true
                        description: >-
                          पहचाने गए **सबसे बड़े** चेहरे की मॉडल-अनुमानित आयु
                          वर्षों में। `null` जब चेहरे की आयु का अनुमान नहीं
                          लगाया जा सका (एक `AGE_NOT_DETECTED` चेतावनी जोड़ी जाती
                          है और कॉल अस्वीकृत हो जाती है)।
                        example: 27.33
                      warnings:
                        type: array
                        description: >-
                          बिना किसी जोखिम वाली स्वीकृति पर खाली। कोई भी
                          प्रविष्टि `status` को `Declined` पर सेट करती है।
                        items:
                          type: object
                          properties:
                            risk:
                              type: string
                              enum:
                                - NO_FACE_DETECTED
                                - LOW_LIVENESS_SCORE
                                - LIVENESS_FACE_ATTACK
                                - AGE_NOT_DETECTED
                                - AGE_BELOW_MINIMUM
                              description: >-
                                मशीन-पठनीय जोखिम कोड। `NO_FACE_DETECTED` —
                                लाइवनेस मॉडल को कोई चेहरा नहीं मिला;
                                `LOW_LIVENESS_SCORE` — लाइवनेस `score`
                                `face_liveness_score_decline_threshold` पर या
                                उससे कम है; `LIVENESS_FACE_ATTACK` — एक
                                प्रेज़ेंटेशन अटैक (फ़ोटो/स्क्रीन/मास्क) का पता
                                चला था; `AGE_NOT_DETECTED` — चेहरे की आयु का
                                अनुमान नहीं लगाया जा सका; `AGE_BELOW_MINIMUM` —
                                अनुमानित आयु `age_estimation_decline_threshold`
                                से कम है। `NO_FACE_DETECTED` और
                                `LOW_LIVENESS_SCORE` परस्पर अनन्य हैं — जब कोई
                                चेहरा नहीं मिलता है तो केवल `NO_FACE_DETECTED`
                                जारी किया जाता है।
                            feature:
                              type: string
                              enum:
                                - LIVENESS
                              description: >-
                                सुविधा जिसने चेतावनी उत्पन्न की। इस endpoint पर
                                हमेशा `LIVENESS`।
                            additional_data:
                              type: object
                              nullable: true
                              additionalProperties: true
                              description: आयु अनुमान चेतावनियों के लिए हमेशा `null`।
                            log_type:
                              type: string
                              enum:
                                - error
                              description: >-
                                गंभीरता। यह endpoint जो भी चेतावनी उत्पन्न करता
                                है, वह एक `error` होती है और `status` को
                                `Declined` पर सेट कर देती है।
                            short_description:
                              type: string
                              description: जोखिम का मानव-पठनीय एक पंक्ति का सारांश।
                            long_description:
                              type: string
                              description: जोखिम का मानव-पठनीय स्पष्टीकरण।
                  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)।
        '400':
          description: >-
            सत्यापन त्रुटि। तब लौटाई जाती है जब `user_image` गायब हो, 5 MB से
            अधिक हो, इसका एक्सटेंशन असमर्थित हो, या जब कोई थ्रेशोल्ड सीमा से
            बाहर हो। बॉडी DRF का मानक फ़ील्ड-त्रुटि एनवेलप है: प्रति आपत्तिजनक
            फ़ील्ड संदेशों की एक सरणी।
          content:
            application/json:
              examples:
                Missing user image:
                  summary: '`user_image` फ़ॉर्म डेटा में शामिल नहीं है'
                  value:
                    user_image:
                      - No file was submitted.
                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
                Threshold out of range:
                  summary: '`face_liveness_score_decline_threshold` 0–100 से बाहर है'
                  value:
                    face_liveness_score_decline_threshold:
                      - Ensure this value is less than or equal to 100.
        '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/age-estimation/' \
              -H 'x-api-key: YOUR_API_KEY' \
              -F 'user_image=@./selfie.jpg' \
              -F 'age_estimation_decline_threshold=18' \
              -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.age_estimation.estimate(
                user_image=open("user_image.jpg", "rb"),
                face_liveness_score_decline_threshold=30.0,
                age_estimation_decline_threshold=18,
                rotate_image=False,
                save_api_request=True,
                vendor_data="user-123",
                metadata={"flow": "age-gate"},
            )
            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.ageEstimation.estimate({
              user_image: await fileFromPath("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              age_estimation_decline_threshold: 18,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "age-gate" },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.AgeEstimation.Estimate(ctx, didit.AgeEstimationEstimateParams{\n\tUserImage:                         didit.FileFromPath(\"user_image.jpg\"),\n\tFaceLivenessScoreDeclineThreshold: didit.Float(30.0),\n\tAgeEstimationDeclineThreshold:     didit.Int(18),\n\tRotateImage:                       didit.Bool(false),\n\tSaveAPIRequest:                    didit.Bool(true),\n\tVendorData:                        didit.String(\"user-123\"),\n\tMetadata:                          didit.Some(map[string]any{\"flow\": \"age-gate\"}),\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.AgeEstimationEstimateParams;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.ageEstimation().estimate(AgeEstimationEstimateParams.builder()
                    .userImage(Path.of("user_image.jpg"))
                    .faceLivenessScoreDeclineThreshold(30.0)
                    .ageEstimationDeclineThreshold(18L)
                    .rotateImage(false)
                    .saveApiRequest(true)
                    .vendorData("user-123")
                    .metadata(Map.of("flow", "age-gate"))
                    .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->ageEstimation->estimate([
                'user_image' => File::fromPath('user_image.jpg'),
                'face_liveness_score_decline_threshold' => 30.0,
                'age_estimation_decline_threshold' => 18,
                'rotate_image' => false,
                'save_api_request' => true,
                'vendor_data' => 'user-123',
                'metadata' => ['flow' => 'age-gate'],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.age_estimation.estimate(
              user_image: Pathname("user_image.jpg"),
              face_liveness_score_decline_threshold: 30.0,
              age_estimation_decline_threshold: 18,
              rotate_image: false,
              save_api_request: true,
              vendor_data: "user-123",
              metadata: { flow: "age-gate" }
            )
            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.AgeEstimation.EstimateAsync(new
            AgeEstimationEstimateParams

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

            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.