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

# JWKS साइनिंग कीज़ प्राप्त करें | Didit Authentication API

> GET /.well-known/jwks.json Didit के सार्वजनिक ES256 कीज़ लौटाता है। kid के आधार पर कैश करें; कीज़ हर 30 दिन में बदलती हैं, एक दिन के ओवरलैप के साथ।

> [!WARNING]
>
> प्रमाणीकरण नया है। ये endpoint आपके एप्लिकेशन के जारीकर्ता (issuer) द्वारा दिए जाते हैं, जैसे `https://<name>.auth.didit.me`, और ये कभी आपकी Didit API कुंजी स्वीकार नहीं करते।

कुंजियाँ हर 30 दिन में रोटेट होती हैं, और हर ओर एक दिन का ओवरलैप रहता है, इसलिए 5 मिनट के लिए कैश की गई JWKS के कारण रोटेशन के दौरान भी सत्यापन जारी रखना संभव रहता है। जब कोई token ऐसा `kid` बताए जो आपके पास नहीं है, तब JWKS को फिर से लाएँ, लेकिन अधिकतम प्रति मिनट एक बार। देखें [कैशिंग और रोटेशन](https://docs.didit.me/hi/authentication/tokens-and-jwks.md#कैशिंग-और-रोटेशन)।


## OpenAPI

````yaml hi/openapi-authentication.json GET /.well-known/jwks.json
openapi: 3.0.3
info:
  title: Didit Authentication API
  version: 1.0.0
  description: >-
    Didit Authentication के सर्वर-फेसिंग endpoints, जो आपके एप्लिकेशन के अंतिम
    उपयोगकर्ताओं के लिए साइन-इन उत्पाद है। Authentication **नया** है और
    2026-11-01 रिलीज़ में प्रोडक्शन में पहुँचेगा।


    ## बेस URL


    प्रत्येक एप्लिकेशन अपना स्वयं का OpenID Connect issuer होता है, और नीचे दिया
    गया प्रत्येक endpoint उस issuer के रूट पर सर्व किया जाता है:


    - लाइव एप्लिकेशन के लिए `https://<name>.auth.didit.me`, या सैंडबॉक्स
    एप्लिकेशन के लिए `https://<name>.sandbox.auth.didit.me`।

    - आपका अपना कस्टम डोमेन, एक बार सक्रिय हो जाने के बाद। यह फिर डिफ़ॉल्ट होस्ट
    को issuer के रूप में बदल देता है: नए tokens इसे `iss` में नामित करते हैं,
    डिस्कवरी इसकी ओर इंगित करती है और पब्लिश करने योग्य कुंजी बदल जाती है।
    डिफ़ॉल्ट होस्ट के तहत जारी किए गए एक्सेस tokens रीफ़्रेश होने तक
    `/session/`, `/step-up/` और `/monitoring-token/` पर विफल हो जाते हैं।


    लाइव और सैंडबॉक्स अलग-अलग एप्लिकेशन हैं, इसलिए वे अलग-अलग कुंजियों वाले
    अलग-अलग issuers हैं। पब्लिश करने योग्य कुंजी `pk_live_` (लाइव) या `pk_test_`
    (सैंडबॉक्स) होती है, जिसके बाद बिना किसी ट्रेलिंग स्लैश के issuer का अनपैडेड
    base64url एन्कोडिंग होता है: issuer खोजने के लिए इसे डिकोड करें। यह एक
    सार्वजनिक पहचानकर्ता है, कोई क्रेडेंशियल नहीं।


    वही JSON endpoints
    `https://apx.didit.me/auth/v2/authentication/{application_id}/` के अंतर्गत
    भी सर्व किए जाते हैं। Tokens हमेशा उपरोक्त issuer का नाम देते हैं, चाहे
    उन्हें किसी भी पते ने जारी किया हो।


    ## क्रेडेंशियल्स


    ये endpoints कभी भी आपकी Didit API कुंजी या कंसोल token स्वीकार नहीं करते
    हैं।


    - डिस्कवरी, JWKS और `POST /token/` कोई क्रेडेंशियल नहीं लेते हैं। क्लाइंट
    सार्वजनिक होते हैं: कोई client secret नहीं होता है, और एक ऑथराइजेशन कोड अपने
    PKCE सत्यापनकर्ता (`S256`) से बंधा होता है। `client_id` आपकी एप्लिकेशन ID
    है।

    - `/session/`, `/step-up/` और `/monitoring-token/` व्यक्ति का एक्सेस token
    लेते हैं: `Authorization: Bearer <access_token>`। प्रत्येक सफल कॉल को सत्र
    पर गतिविधि माना जाता है, इसलिए यह सत्र के निष्क्रिय टाइमआउट को पुनः आरंभ
    करता है।


    ## अनुरोध बॉडी


    बॉडी स्वीकार करने वाला प्रत्येक endpoint JSON, फ़ॉर्म-एन्कोडेड और मल्टीपार्ट
    बॉडी स्वीकार करता है। यह दस्तावेज़ JSON को सूचीबद्ध करता है, साथ ही `POST
    /token/` के लिए फ़ॉर्म-एन्कोडेड बॉडी को भी, जैसा कि OAuth क्लाइंट भेजते हैं।
    जो फ़ील्ड endpoint स्वीकार नहीं करता है, उस पर `400 {"<field>":
    "unknown_field"}` मिलता है।


    ## Tokens


    - **Access token**: हेडर `typ: at+jwt` वाला एक ES256 JWT, जो अधिकतम 5 मिनट
    के लिए और कभी भी अपने सत्र से अधिक समय के लिए मान्य नहीं होता है। Claims:
    `AccessTokenClaims`।

    - **ID token**: हेडर `typ: JWT` वाला एक ES256 JWT। Claims: `IDTokenClaims`।
    इसे कभी भी एक्सेस token के रूप में स्वीकार नहीं किया जाता है।

    - **Refresh token**: एक रैंडम स्ट्रिंग जो प्रत्येक उपयोग पर रोटेट होती है।
    पहले से उपयोग किया गया रीफ़्रेश token दोबारा भेजने से सत्र रद्द हो जाता है।


    `GET /.well-known/jwks.json` से प्राप्त कुंजियों के साथ किसी token को
    सत्यापित करें: एल्गोरिदम `ES256` होना चाहिए, `typ` को token प्रकार से मेल
    खाना चाहिए, `iss` आपके द्वारा कॉन्फ़िगर किए गए issuer के बराबर होना चाहिए और
    `aud` आपकी एप्लिकेशन ID होनी चाहिए। ऑफ़लाइन सत्यापन किसी रद्द किए गए सत्र को
    केवल तभी देखता है जब उसका एक्सेस token समाप्त हो जाता है; `GET /session/`
    इसका त्वरित चेक है।


    ## त्रुटियाँ


    | बॉडी | कब |

    | --- | --- |

    | `{"error": "<code>"}` | `POST /token/` से त्रुटियाँ, सभी स्टेटस `400` के
    साथ, [RFC 6749 section
    5.2](https://www.rfc-editor.org/rfc/rfc6749#section-5.2) के बॉडी प्रारूप
    में: `invalid_grant`, `invalid_client` और Didit का `mfa_required`। सर्विस
    त्रुटियाँ: `temporarily_unavailable`, `monitoring_unavailable`,
    `monitoring_disabled`। |

    | `{"<field>": ["<message>"]}` या `{"<field>": "<code>"}` | एक अनुरोध फ़ील्ड
    सत्यापन में विफल रहा। `non_field_errors` सभी फ़ील्ड्स में लागू नियम को इंगित
    करता है, और `unknown_field` उस फ़ील्ड को जिसे endpoint स्वीकार नहीं करता है।
    |

    | `{"detail": "<message>"}` | `401` (`invalid_token`), `403`
    (`origin_not_allowed`), `404` (अज्ञात एप्लिकेशन या step-up) और `429` (रेट
    लिमिट)। साथ ही पार्स न की जा सकने वाली बॉडी के लिए `400` (`JSON parse error
    - ...`), endpoint द्वारा समर्थित न होने वाले मेथड के लिए `405` और असमर्थित
    `Content-Type` के लिए `415`। |


    `401` में `WWW-Authenticate: Bearer` भी शामिल होता है, और `429` में सेकंड
    में `Retry-After` शामिल होता है।


    दो अस्वीकृतियाँ JSON नहीं हैं। जो पता issuer नहीं है, उसे इन endpoints तक
    पहुँचने से पहले ही अस्वीकार कर दिया जाता है, उदाहरण के लिए किसी अप्रयुक्त
    `*.auth.didit.me` नाम के लिए रिक्त `404` के साथ। एक `step_up_id` जो UUID
    नहीं है, उसे एक `404` पेज मिलता है।


    ## रेट लिमिट


    एक अनुरोध को दो लेयर्स को पार करना होता है।


    **Endpoint सीमाएँ**, प्रति क्लाइंट IP पता, प्रति एप्लिकेशन और प्रति endpoint
    गिनी जाती हैं:


    - डिस्कवरी और JWKS: 1,200 अनुरोध प्रति मिनट और 12,000 प्रति घंटा।

    - अन्य प्रत्येक endpoint: 30 अनुरोध प्रति मिनट और 300 प्रति घंटा। `GET` और
    `DELETE /session/` एक ही गणना साझा करते हैं।


    सीमा पार होने पर: `429 {"detail": "Too many requests from this IP address.
    Please wait before trying again. Expected available in 60 seconds."}`, या
    प्रति घंटा सीमा के लिए `3600 seconds`।


    **बॉट सुरक्षा**, प्रत्येक `POST` और `DELETE` पर। इसके बकेट एप्लिकेशन के सभी
    `POST` और `DELETE` अनुरोधों द्वारा साझा किए जाते हैं, जिसमें होस्ट किए गए
    साइन-इन चरण भी शामिल हैं, और यह लगातार रिफिल होते हैं:


    - 60 अनुरोध प्रति मिनट प्रति क्लाइंट IP पता।

    - 30 अनुरोध प्रति मिनट प्रति डिवाइस, उन अनुरोधों के लिए जो अपने डिवाइस की
    पहचान करते हैं, जैसा कि ब्राउज़र और नेटिव SDK करते हैं।

    - पूरे एप्लिकेशन के लिए 3,000 अनुरोध प्रति मिनट, प्रत्येक IP पते पर। Token
    रीफ़्रेश (`POST /token/` साथ में `grant_type=refresh_token`) इसके बजाय अपने
    स्वयं के बकेट का उपयोग करते हैं: पूरे एप्लिकेशन के लिए 6,000 प्रति मिनट।


    बकेट की सीमा पार होने पर: `429 {"detail": "rate_limited Expected available
    in N seconds."}` (N के 1 होने पर `1 second.`)। प्रति-IP बकेट सभी endpoints
    में फैला होता है, इसलिए एक पता जो token, step-up और साइन-आउट कॉल को मिलाता
    है, वह किसी भी endpoint सीमा तक पहुँचने से पहले ही इसे खाली कर सकता है।
    एप्लिकेशन बकेट एप्लिकेशन के प्रत्येक क्लाइंट की गणना करता है, जिसमें
    ब्राउज़र भी शामिल हैं।


    दोनों लेयर्स endpoint के चलने से पहले उत्तर देती हैं, इसलिए जिस अनुरोध को
    `429` मिला वह निष्पादित नहीं हुआ: `Retry-After` के बाद पुनः प्रयास करें,
    जिसमें रीफ़्रेश भी शामिल है।


    ## ब्राउज़र अनुरोध


    एक अनुरोध जिसमें `Origin` हेडर होता है, उसे एप्लिकेशन के अपने मूल या इसके
    अनुमत मूल में से किसी एक से आना चाहिए, अन्यथा इसे `403 origin_not_allowed`
    प्राप्त होता है। सर्वर-टू-सर्वर अनुरोध कोई `Origin` नहीं भेजते हैं।


    ## यहाँ क्या शामिल नहीं है


    ये रूट होस्टेड पेज, ब्राउज़र और नेटिव SDK और AI एजेंटों को सर्व करते हैं। वे
    सर्वर अनुबंध का हिस्सा नहीं हैं, और सर्वर SDK उन्हें कॉल नहीं करते हैं:


    - साइन-इन चरण: `POST /authorize/`, `POST /password/`, `/email/*`,
    `/phone/*`, `/password-reset/*`, `/passkeys/*`, `/mfa/*`, `/social/*` और
    `/protection/complete/`।

    - होस्टेड पेज और कॉलबैक: `/sign-in`, `/magic`, `/invite`, `/reset`,
    `/verify/`, `/sso/*`, `/wallet/callback/`, `/logo/` और `/.well-known/` के
    अंतर्गत नेटिव ऐप एसोसिएशन फ़ाइलें।

    - एजेंट एक्सेस: `/agents/*` और `/grants/`, जिसमें `GET /agents/session/`
    शामिल है, जो किसी AI एजेंट के एक्सेस token के लिए लाइव चेक है। एजेंट एक्सेस
    अनुबंध के इस संस्करण का हिस्सा नहीं है।

    - Authentication के लिए कंसोल प्रबंधन API, जो कंसोल सत्र लेता है।


    Authentication इवेंट्स अभी webhook के रूप में डिलीवर नहीं किए जाते हैं,
    इसलिए यह दस्तावेज़ किसी webhook को परिभाषित नहीं करता है।
servers:
  - url: https://{issuer}
    description: 'आपकी एप्लिकेशन का जारीकर्ता: इसका साइन-इन मूल।'
    variables:
      issuer:
        default: your-app.auth.didit.me
        description: >-
          जारीकर्ता का होस्ट: `<name>.auth.didit.me` (लाइव),
          `<name>.sandbox.auth.didit.me` (सैंडबॉक्स) या आपका सक्रिय कस्टम डोमेन।
security: []
tags:
  - name: Issuer
    description: टोकन सत्यापित करने के लिए डिस्कवरी और साइनिंग कीज़।
  - name: Tokens
    description: प्राधिकरण कोड और रीफ़्रेश ग्रांट।
  - name: Sessions
    description: एक्सेस token के पीछे के सत्र की जांच करें और उसे समाप्त करें।
  - name: Step-ups
    description: किसी संवेदनशील कार्रवाई से पहले सत्यापन।
  - name: Monitoring
    description: लेन-देन निगरानी इवेंट के लिए डिवाइस क्रेडेंशियल्स।
paths:
  /.well-known/jwks.json:
    get:
      tags:
        - Issuer
      summary: साइनिंग कुंजियाँ प्राप्त करें
      description: >-
        एप्लिकेशन की सार्वजनिक ES256 कुंजियाँ। प्रत्येक token `kid` हेडर में
        अपनी कुंजी का नाम देता है।


        कुंजियाँ हर 30 दिनों में रोटेट होती हैं। अगली कुंजी हस्ताक्षर शुरू करने
        से एक दिन पहले प्रकाशित की जाती है, और पिछली कुंजी बंद होने के एक दिन
        बाद तक प्रकाशित रहती है, ताकि 5 मिनट तक कैश किया गया JWKS रोटेशन के
        दौरान सत्यापन जारी रखे। `kid` द्वारा कुंजियों को कैश करें और जब कोई
        token आपके पास मौजूद न होने वाले `kid` का नाम दे, तो अधिक से अधिक प्रति
        मिनट एक बार JWKS को फिर से फ़ेच करें। जब Didit किसी कंप्रोमाइज़ हुई
        कुंजी को रद्द करता है, तो वह कुंजी इस दस्तावेज़ से तुरंत हट जाती है और
        `GET /session/` उसके द्वारा हस्ताक्षरित प्रत्येक token को अस्वीकार कर
        देता है। एक प्रतिस्थापन कुंजी एक दिन पहले प्रकाशित किए बिना तुरंत
        हस्ताक्षर करना शुरू कर देती है, इसलिए 5 मिनट पहले तक कैश किया गया JWKS
        अभी भी रद्द की गई कुंजी को स्वीकार करता है और प्रतिस्थापन को अभी तक नहीं
        जानता है।
      operationId: authentication_get_jwks
      responses:
        '200':
          description: प्रकाशित कुंजियाँ।
          headers:
            Cache-Control:
              description: >-
                `public, max-age=300`: आप और साझा कैश 5 मिनट तक एक सफल रिस्पॉन्स
                रख सकते हैं, जो एक एक्सेस token का जीवनकाल है।
              schema:
                type: string
                example: public, max-age=300
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JSONWebKeySet'
              examples:
                Keys:
                  summary: एक हस्ताक्षर कुंजी
                  value:
                    keys:
                      - kty: EC
                        crv: P-256
                        x: ZDN2unLMultuZwNY_ZKMvsKLRrlC_usPFZyK77cnDO8
                        'y': CfLKoaJNvhFpDWqG56H8dD_j0f1c93RdR63bhIdTh3I
                        kid: k_8sJ2dQvX0nLr5TfYb3HkPw
                        use: sig
                        alg: ES256
        '403':
          $ref: '#/components/responses/OriginNotAllowed'
        '404':
          $ref: '#/components/responses/ApplicationNotFound'
        '429':
          $ref: '#/components/responses/RateLimited'
        '503':
          $ref: '#/components/responses/TemporarilyUnavailable'
      security:
        - {}
components:
  schemas:
    JSONWebKeySet:
      type: object
      description: >-
        एप्लिकेशन की प्रकाशित सार्वजनिक हस्ताक्षर कुंजियाँ। आमतौर पर एक कुंजी;
        रोटेशन के आसपास दो, जब अगली कुंजी हस्ताक्षर करने से एक दिन पहले प्रकाशित
        की जाती है और पिछली कुंजी बंद होने के एक दिन बाद तक रहती है।
      required:
        - keys
      properties:
        keys:
          type: array
          items:
            $ref: '#/components/schemas/JSONWebKey'
    JSONWebKey:
      type: object
      description: JWK प्रारूप (RFC 7517) में एक P-256 सार्वजनिक कुंजी।
      required:
        - kty
        - crv
        - x
        - 'y'
        - kid
        - use
        - alg
      properties:
        kty:
          type: string
          enum:
            - EC
        crv:
          type: string
          enum:
            - P-256
        x:
          type: string
          description: सार्वजनिक बिंदु का x निर्देशांक, base64url।
          example: ZDN2unLMultuZwNY_ZKMvsKLRrlC_usPFZyK77cnDO8
        'y':
          type: string
          description: सार्वजनिक बिंदु का y निर्देशांक, base64url।
          example: CfLKoaJNvhFpDWqG56H8dD_j0f1c93RdR63bhIdTh3I
        kid:
          type: string
          description: >-
            कुंजी ID, इस कुंजी द्वारा हस्ताक्षरित प्रत्येक टोकन के हेडर में
            `kid`। नई कुंजी ID `k_` से शुरू होती हैं।
          example: k_8sJ2dQvX0nLr5TfYb3HkPw
        use:
          type: string
          enum:
            - sig
        alg:
          type: string
          enum:
            - ES256
    Detail:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          example: invalid_token
    OAuthError:
      title: OAuth error
      type: object
      description: एक OAuth त्रुटि (RFC 6749 धारा 5.2) या एक सेवा त्रुटि।
      required:
        - error
      properties:
        error:
          type: string
          example: invalid_grant
  responses:
    OriginNotAllowed:
      description: >-
        अनुरोध में एक ऐसा `Origin` था जो न तो एप्लिकेशन का अपना है और न ही इसके
        स्वीकृत ओरिजिन में है। सर्वर अनुरोध कोई `Origin` नहीं भेजते हैं।
      headers:
        Cache-Control:
          description: 'हमेशा `no-store`: इस रिस्पॉन्स को कभी कैश न करें।'
          schema:
            type: string
            example: no-store
        Pragma:
          description: हमेशा `no-cache`।
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            OriginNotAllowed:
              summary: ऑरिजिन की अनुमति नहीं है
              value:
                detail: origin_not_allowed
    ApplicationNotFound:
      description: >-
        पता किसी एप्लिकेशन का है, लेकिन इसके लिए प्रमाणीकरण सक्रिय नहीं है;
        `apx.didit.me` पते पर, एप्लिकेशन ID अज्ञात है। जो पता किसी एप्लिकेशन का
        नहीं है, उसे endpoint तक पहुंचने से पहले ही अस्वीकार कर दिया जाता है, और
        वह रिस्पॉन्स JSON नहीं होता है।
      headers:
        Cache-Control:
          description: 'हमेशा `no-store`: इस रिस्पॉन्स को कभी कैश न करें।'
          schema:
            type: string
            example: no-store
        Pragma:
          description: हमेशा `no-cache`।
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            ApplicationNotFound:
              summary: अज्ञात एप्लिकेशन
              value:
                detail: No Configuration matches the given query.
    RateLimited:
      description: >-
        इस endpoint के लिए इस IP पते से बहुत सारे अनुरोध आए हैं, या `POST` या
        `DELETE` पर बॉट सुरक्षा बकेट खाली है। कुछ भी निष्पादित नहीं हुआ:
        `Retry-After` सेकंड प्रतीक्षा करें, फिर पुनः प्रयास करें।
      headers:
        Retry-After:
          description: पुनः प्रयास करने से पहले प्रतीक्षा करने के सेकंड।
          schema:
            type: integer
            example: 60
        Cache-Control:
          description: 'हमेशा `no-store`: इस रिस्पॉन्स को कभी कैश न करें।'
          schema:
            type: string
            example: no-store
        Pragma:
          description: हमेशा `no-cache`।
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Detail'
          examples:
            RateLimited:
              summary: Endpoint सीमा
              value:
                detail: >-
                  Too many requests from this IP address. Please wait before
                  trying again. Expected available in 60 seconds.
            BotProtection:
              summary: बॉट सुरक्षा सीमा (POST और DELETE)
              value:
                detail: rate_limited Expected available in 2 seconds.
    TemporarilyUnavailable:
      description: >-
        अनुरोध जिस सेवा पर निर्भर करता है वह कुछ समय के लिए अनुपलब्ध है। बैकऑफ़
        के साथ पुनः प्रयास करें।
      headers:
        Cache-Control:
          description: 'हमेशा `no-store`: इस रिस्पॉन्स को कभी कैश न करें।'
          schema:
            type: string
            example: no-store
        Pragma:
          description: हमेशा `no-cache`।
          schema:
            type: string
            example: no-cache
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OAuthError'
          examples:
            TemporarilyUnavailable:
              summary: बाद में पुनः प्रयास करें
              value:
                error: temporarily_unavailable

````

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