> ## 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 में लंबित चरण स्थिति ओवरराइड रद्द करें। उपयोगकर्ता फ़्लो पूरा करने से पहले ओवरराइड लागू नहीं होगा और चरण की स्थिति वही रहेगी।



फ़ीचर ओवरराइड रद्द करने का प्रॉम्प्ट
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Cancel a check (feature) status override on a Didit session that still waits for the person to finish the flow, so it never applies.

Endpoint:
POST https://verification.didit.me/v3/session/{session_id}/features/overrides/{override_id}/cancel/

Authentication:
x-api-key (client API key) or a user-auth token. Privilege: write:sessions. A scoped API key needs write access to decisions.

Path parameters:
\- session_id (UUID): KYC or KYB; Didit resolves it against both session types.
\- override_id (UUID): the id of the override, from the "override" object returned by PATCH /v3/session/{session_id}/features/{node_id}/update-status/ or from GET /v3/session/{session_id}/features/overrides/.

Request body: none.

Only an override whose state is "pending_until_flow_finishes" can be cancelled.

Response (200): the override, with state "cancelled", cancelled_at set and cancel_reason "cancelled_by_reviewer".

Side effects:
\- The check keeps its current status.
\- The cancellation is recorded in the session's activity as FEATURE_OVERRIDE_CANCELLED.
\- No webhook is sent.

curl example:
curl -X POST https://verification.didit.me/v3/session/<SESSION_ID>/features/overrides/<OVERRIDE_ID>/cancel/ \
-H "x-api-key: <API_KEY>"

Failure modes:
\- 401: the scoped API key has expired.
\- 403: missing credentials (a wrong, revoked or expired key gets 401), the caller lacks write:sessions, a scoped key lacks decisions write, or the session belongs to another application ({ "detail": "You do not have permission to perform this action." }).
\- 404: { "detail": "Not found." } when no session with this session_id exists, or { "detail": "Override not found." } when the session has no override with this override_id.
\- 409: { "detail": "This override is no longer pending: it already applied or was cancelled.", "code": "feature_override_not_pending" }.

For end-to-end Didit integration, paste in the full prompt at /integration/integration-prompt.`

\</pre>



      
      

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

जब आप किसी व्यक्ति के वर्कफ़्लो में रहते हुए `defer_until_flow_finishes: true` के साथ कोई चरण ओवरराइड करते हैं, तो ओवरराइड प्रतीक्षा करता है और वर्कफ़्लो समाप्त होने पर लागू होता है।
यदि आप नहीं चाहते कि यह लागू हो, तो इसे यहाँ रद्द करें।जाँच अपनी मौजूदा स्थिति बनाए रखती है।
रद्दीकरण को सत्र की गतिविधि में `FEATURE_OVERRIDE_CANCELLED` के रूप में दर्ज किया जाता है, और कोई webhook नहीं भेजा जाता।
रिस्पॉन्स में वह ओवरराइड होता है जिसमें `state: cancelled` और `cancel_reason: cancelled_by_reviewer` है।## ओवरराइड ID खोजें[Update Feature Status](https://docs.didit.me/hi/sessions-api/update-feature-status.md) से लौटाए गए `override` ऑब्जेक्ट का `id` लें, या [List Feature Overrides](https://docs.didit.me/hi/sessions-api/list-feature-overrides.md) से सत्र के ओवरराइड सूचीबद्ध करें और वह चुनें जिसका `state` `pending_until_flow_finishes` हो।## जब रद्द करना विफल होजो ओवरराइड पहले ही लागू हो चुका है या रद्द किया जा चुका है, वह `409` लौटाता है, जिसका कोड `feature_override_not_pending` है।
ओवरराइड लागू होने के बाद जाँच बदलने के लिए, इसके बजाय नया [Update Feature Status](https://docs.didit.me/hi/sessions-api/update-feature-status.md) अनुरोध भेजें।## संबंधित- [Update Feature Status](https://docs.didit.me/hi/sessions-api/update-feature-status.md): किसी एक चरण की स्थिति ओवरराइड करें, अभी या वर्कफ़्लो समाप्त होने के बाद।
- [List Feature Overrides](https://docs.didit.me/hi/sessions-api/list-feature-overrides.md): किसी सत्र का हर ओवरराइड और उसकी स्थिति।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/session/{sessionId}/features/overrides/{overrideId}/cancel/
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}/features/overrides/{overrideId}/cancel/:
    post:
      tags:
        - Sessions
      summary: फ़्लो समाप्त होने की प्रतीक्षा करने वाले चेक ओवरराइड को रद्द करें
      description: >-
        किसी सुविधा (चरण) की स्थिति के ओवरराइड को रद्द करें जो अभी भी
        `pending_until_flow_finishes` है, ताकि यह कभी लागू न हो। चेक अपनी स्थिति
        बनाए रखता है, रद्दीकरण सत्र की गतिविधि में `FEATURE_OVERRIDE_CANCELLED`
        के रूप में दर्ज किया जाता है, और कोई webhook नहीं भेजा जाता है।
        रिस्पॉन्स `state: cancelled` और `cancel_reason: cancelled_by_reviewer`
        के साथ ओवरराइड है।


        पहले से लागू या रद्द किया गया ओवरराइड `feature_override_not_pending` कोड
        के साथ `409` लौटाता है। `GET
        /v3/session/{sessionId}/features/overrides/` के साथ या सुविधा स्थिति
        अपडेट द्वारा लौटाए गए `override` में ओवरराइड ID खोजें।


        `write:sessions` विशेषाधिकार की आवश्यकता है; स्कोप्ड API कुंजी को
        निर्णयों के लिए राइट एक्सेस की आवश्यकता होती है।
      operationId: post_v3_session_feature_override_cancel
      parameters:
        - in: path
          name: sessionId
          required: true
          description: >-
            सत्यापन सत्र का UUID। उपयोगकर्ता (KYC) और व्यवसाय (KYB) दोनों सत्र
            ID स्वीकार करता है।
          schema:
            type: string
            format: uuid
            example: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        - in: path
          name: overrideId
          required: true
          description: रद्द करने के लिए ओवरराइड का `id`।
          schema:
            type: string
            format: uuid
            example: 9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3
      responses:
        '200':
          description: ओवरराइड रद्द कर दिया गया है और कभी लागू नहीं होगा।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FeatureStatusOverride'
              examples:
                Cancelled:
                  summary: रद्द किया गया ओवरराइड
                  value:
                    id: 9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3
                    node_id: feature_liveness_1
                    feature_type: ''
                    feature_model: Face
                    previous_status: Declined
                    new_status: Approved
                    state: cancelled
                    forced: false
                    reason: Liveness retried with a reviewer present.
                    requested_by:
                      email: reviewer@example.com
                      name: Alex Reviewer
                      type: CONSOLE_USER
                    requested_at: '2026-10-13T09:15:00Z'
                    applied_at: null
                    cancelled_at: '2026-10-13T09:20:00Z'
                    cancel_reason: cancelled_by_reviewer
        '401':
          description: स्कोप्ड API कुंजी की समय-सीमा समाप्त हो गई है।
          content:
            application/json:
              examples:
                Expired API Key:
                  summary: अपनी समाप्ति तिथि पार कर चुकी स्कोप्ड API कुंजी
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            क्रेडेंशियल मौजूद नहीं हैं, कॉलर के पास `write:sessions` विशेषाधिकार
            नहीं है, स्कोप्ड API कुंजी के पास इस endpoint के लिए आवश्यक एक्सेस
            नहीं है, या ऐसा `session_id` है जो किसी अन्य एप्लिकेशन का है।
          content:
            application/json:
              examples:
                Invalid Credentials:
                  summary: अनुपलब्ध या अमान्य x-api-key
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Missing Privilege:
                  summary: कॉलर के पास write:sessions की कमी है
                  value:
                    detail: You do not have permission to perform this action.
                Scoped Key Without Access:
                  summary: इस एक्सेस के बिना स्कोप्ड API कुंजी
                  value:
                    detail: This API key has no write access to decisions.
        '404':
          description: >-
            इस `session_id` वाला कोई KYC या KYB सत्र मौजूद नहीं है, या सत्र में
            इस `overrideId` वाला कोई ओवरराइड नहीं है।
          content:
            application/json:
              examples:
                Not Found:
                  summary: अज्ञात session_id
                  value:
                    detail: Not found.
                Override Not Found:
                  summary: सत्र पर इस id वाला कोई ओवरराइड नहीं है
                  value:
                    detail: Override not found.
        '409':
          description: ओवरराइड पहले ही लागू हो चुका है या रद्द कर दिया गया था।
          content:
            application/json:
              examples:
                Not Pending:
                  summary: केवल प्रतीक्षारत ओवरराइड को रद्द किया जा सकता है
                  value:
                    detail: >-
                      This override is no longer pending: it already applied or
                      was cancelled.
                    code: feature_override_not_pending
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST \
              https://verification.didit.me/v3/session/3fa85f64-5717-4562-b3fc-2c963f66afa6/features/overrides/9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3/cancel/ \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.sessions.cancel_feature_override(
                "3fa85f64-5717-4562-b3fc-2c963f66afa6",
                "9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

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

            const result = await didit.sessions.cancelFeatureOverride(
              "3fa85f64-5717-4562-b3fc-2c963f66afa6",
              "9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3",
            );
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Sessions.CancelFeatureOverride(ctx, \"3fa85f64-5717-4562-b3fc-2c963f66afa6\", \"9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3\")\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.sessions().cancelFeatureOverride("3fa85f64-5717-4562-b3fc-2c963f66afa6",
            "9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3");

            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $result =
            $didit->sessions->cancelFeatureOverride('3fa85f64-5717-4562-b3fc-2c963f66afa6',
            '9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3');

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

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

            result = didit.sessions.cancel_feature_override(
              "3fa85f64-5717-4562-b3fc-2c963f66afa6",
              "9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await
            client.Sessions.CancelFeatureOverrideAsync("3fa85f64-5717-4562-b3fc-2c963f66afa6",
            "9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3");

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    FeatureStatusOverride:
      type: object
      description: >-
        `PATCH /v3/session/{sessionId}/features/{nodeId}/update-status/` के साथ
        किए गए चेक (सुविधा) स्थिति का एक ओवरराइड: यह क्या बदलता है, क्या यह लागू
        हुआ या अभी भी व्यक्ति द्वारा फ़्लो पूरा करने की प्रतीक्षा कर रहा है,
        किसने अनुरोध किया और क्यों।
      required:
        - id
        - node_id
        - feature_type
        - feature_model
        - previous_status
        - new_status
        - state
        - forced
        - reason
        - requested_by
        - requested_at
        - applied_at
        - cancelled_at
        - cancel_reason
      properties:
        id:
          type: string
          format: uuid
          description: ओवरराइड का पहचानकर्ता। इसे रद्द करने वाले endpoint पर पास करें।
          example: 7c9e6679-7425-40de-944b-e07fc1f90ae7
        node_id:
          type: string
          description: >-
            अनुरोध में नामित वर्कफ़्लो नोड (नोड के बिना वाले चरण के लिए
            `default`)।
          example: feature_ocr_1
        feature_type:
          type: string
          description: >-
            अनुरोध द्वारा पास किया गया `feature_type`, या यदि कोई पास नहीं किया
            गया तो खाली स्ट्रिंग।
          example: ''
        feature_model:
          type: string
          description: >-
            ओवरराइड की गई जाँच का प्रकार, उदाहरण के लिए `KYC`, `Face`, `AML` या
            `GeolocationCheck`।
          example: KYC
        previous_status:
          type: string
          enum:
            - Not Finished
            - Approved
            - Declined
            - In Review
            - Resub Requested
          description: ओवरराइड का अनुरोध किए जाने के समय जाँच की स्थिति।
          example: In Review
        new_status:
          type: string
          enum:
            - Approved
            - Declined
            - In Review
          description: वह स्थिति जिसे ओवरराइड सेट करता है।
          example: Approved
        state:
          type: string
          enum:
            - applied
            - pending_until_flow_finishes
            - cancelled
          description: >-
            `applied`: जांच की नई स्थिति है। `pending_until_flow_finishes`:
            ओवरराइड प्रतीक्षा करता है और तब लागू होता है जब व्यक्ति फ़्लो पूरा
            करता है। `cancelled`: इसने प्रतीक्षा की और कभी लागू नहीं हुआ
            (`cancel_reason` देखें)।
          example: applied
        forced:
          type: boolean
          description: >-
            `true` जब ओवरराइड तुरंत लागू हो गया, जबकि व्यक्ति अभी भी फ़्लो में
            था।
          example: false
        reason:
          type: string
          nullable: true
          description: अनुरोध के साथ भेजा गया `comment`, या `null`।
          example: Document manually verified by compliance.
        requested_by:
          type: object
          nullable: true
          description: ओवरराइड का अनुरोध किसने किया, या ज्ञात न होने पर `null`।
          properties:
            email:
              type: string
              format: email
              nullable: true
              description: >-
                कंसोल उपयोगकर्ता का ईमेल, या API कुंजियों और सिस्टम के लिए
                `null`।
              example: reviewer@example.com
            name:
              type: string
              nullable: true
              description: अनुरोधकर्ता का डिस्प्ले नाम, या `null`।
              example: Alex Reviewer
            type:
              type: string
              enum:
                - CONSOLE_USER
                - API_KEY
                - SYSTEM
              description: >-
                अनुरोध किसने किया: एक कंसोल उपयोगकर्ता, एक API कुंजी, या स्वयं
                Didit।
              example: CONSOLE_USER
        requested_at:
          type: string
          format: date-time
          description: ओवरराइड का अनुरोध कब किया गया था।
          example: '2026-10-13T09:15:00Z'
        applied_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            जब जाँच ने नई स्थिति ग्रहण की, या प्रतीक्षा करते समय या रद्द हो जाने
            पर `null`।
          example: '2026-10-13T09:15:00Z'
        cancelled_at:
          type: string
          format: date-time
          nullable: true
          description: जब एक प्रतीक्षारत ओवरराइड रद्द कर दिया गया था, या `null`।
          example: null
        cancel_reason:
          type: string
          nullable: true
          enum:
            - cancelled_by_reviewer
            - replaced
            - check_changed
            - session_closed
            - null
          description: >-
            प्रतीक्षारत ओवरराइड कभी लागू क्यों नहीं हुआ, या `null`।
            `cancelled_by_reviewer`: कैंसल endpoint से रद्द किया गया।
            `replaced`: उसी जाँच पर नए ओवरराइड ने इसे बदल दिया। `check_changed`:
            व्यक्ति ने फ़्लो पूरा करने से पहले जाँच को दोबारा किया।
            `session_closed`: व्यक्ति द्वारा इसे पूरा करने से पहले सत्र फ़्लो से
            बाहर हो गया (छोड़ा गया, समय-सीमा समाप्त, या फ़्लो के बीच में निर्णय
            लिया गया)।
          example: null
  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.