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

# Cancel Feature Override

> Cancel a step status override that still waits for the person to finish the flow, so it never applies and the step keeps its status.



Cancel Feature Override Prompt
        Copy prompt to clipboard



      
      

\<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: invalid credentials, 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>



      
      

Paste into

When you override a step with `defer_until_flow_finishes: true` while the person is still in the flow, the override waits and applies when the flow finishes.
Cancel it here if you no longer want it to apply.The check keeps its current status.
The cancellation is recorded in the session's activity as `FEATURE_OVERRIDE_CANCELLED`, and no webhook is sent.
The response is the override with `state: cancelled` and `cancel_reason: cancelled_by_reviewer`.## Find the override IDUse the `id` of the `override` object returned by [Update Feature Status](/sessions-api/update-feature-status.md), or list the session's overrides with [List Feature Overrides](/sessions-api/list-feature-overrides.md) and pick one whose `state` is `pending_until_flow_finishes`.## When cancelling failsAn override that already applied or was cancelled returns `409` with the code `feature_override_not_pending`.
To change a check after its override applied, send a new [Update Feature Status](/sessions-api/update-feature-status.md) request instead.## Related- [Update Feature Status](/sessions-api/update-feature-status.md): override one step's status, now or once the flow finishes.
- [List Feature Overrides](/sessions-api/list-feature-overrides.md): every override of a session and its state.


## OpenAPI

````yaml POST /v3/session/{sessionId}/features/overrides/{overrideId}/cancel/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: Identity verification API. Authenticate with x-api-key header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/session/{sessionId}/features/overrides/{overrideId}/cancel/:
    post:
      tags:
        - Sessions
      summary: Cancel a check override that waits for the flow to finish
      description: >-
        Cancel an override of a feature (step) status that is still
        `pending_until_flow_finishes`, so it never applies. The check keeps its
        status, the cancellation is recorded in the session's activity as
        `FEATURE_OVERRIDE_CANCELLED`, and no webhook is sent. The response is
        the override with `state: cancelled` and `cancel_reason:
        cancelled_by_reviewer`.


        An override that already applied or was cancelled returns `409` with the
        code `feature_override_not_pending`. Find override IDs with `GET
        /v3/session/{sessionId}/features/overrides/` or in the `override`
        returned by the feature status update.


        Requires the `write:sessions` privilege; a scoped API key needs write
        access to decisions.
      operationId: post_v3_session_feature_override_cancel
      parameters:
        - in: path
          name: sessionId
          required: true
          description: >-
            UUID of the verification session. Accepts both user (KYC) and
            business (KYB) session IDs.
          schema:
            type: string
            format: uuid
            example: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        - in: path
          name: overrideId
          required: true
          description: The `id` of the override to cancel.
          schema:
            type: string
            format: uuid
            example: 9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3
      responses:
        '200':
          description: The override is cancelled and will never apply.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FeatureStatusOverride'
              examples:
                Cancelled:
                  summary: The cancelled override
                  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: The scoped API key has expired.
          content:
            application/json:
              examples:
                Expired API Key:
                  summary: Scoped API key past its expiry date
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            Missing or invalid credentials, a caller without the
            `write:sessions` privilege, a scoped API key without the access this
            endpoint needs, or a `session_id` that belongs to another
            application.
          content:
            application/json:
              examples:
                Invalid Credentials:
                  summary: Missing or invalid x-api-key
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Missing Privilege:
                  summary: Caller lacks write:sessions
                  value:
                    detail: You do not have permission to perform this action.
                Scoped Key Without Access:
                  summary: Scoped API key without this access
                  value:
                    detail: This API key has no write access to decisions.
        '404':
          description: >-
            No KYC or KYB session with this `session_id` exists, or the session
            has no override with this `overrideId`.
          content:
            application/json:
              examples:
                Not Found:
                  summary: Unknown session_id
                  value:
                    detail: Not found.
                Override Not Found:
                  summary: No override with this id on the session
                  value:
                    detail: Override not found.
        '409':
          description: The override already applied or was cancelled.
          content:
            application/json:
              examples:
                Not Pending:
                  summary: Only a waiting override can be cancelled
                  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: |-
            import requests

            response = requests.post(
                "https://verification.didit.me/v3/session/3fa85f64-5717-4562-b3fc-2c963f66afa6/features/overrides/9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3/cancel/",
                headers={"x-api-key": "YOUR_API_KEY"},
            )
            response.raise_for_status()
            print(response.json())
components:
  schemas:
    FeatureStatusOverride:
      type: object
      description: >-
        One override of a check (feature) status made with `PATCH
        /v3/session/{sessionId}/features/{nodeId}/update-status/`: what it
        changes, whether it applied or still waits for the person to finish the
        flow, who asked and why.
      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: Identifier of the override. Pass it to the cancel endpoint.
          example: 7c9e6679-7425-40de-944b-e07fc1f90ae7
        node_id:
          type: string
          description: >-
            The workflow node the request named (`default` for a step without a
            node).
          example: feature_ocr_1
        feature_type:
          type: string
          description: >-
            The `feature_type` the request passed, or an empty string when it
            passed none.
          example: ''
        feature_model:
          type: string
          description: >-
            The kind of check that was overridden, for example `KYC`, `Face`,
            `AML` or `GeolocationCheck`.
          example: KYC
        previous_status:
          type: string
          enum:
            - Not Finished
            - Approved
            - Declined
            - In Review
            - Resub Requested
          description: The check's status when the override was requested.
          example: In Review
        new_status:
          type: string
          enum:
            - Approved
            - Declined
            - In Review
          description: The status the override sets.
          example: Approved
        state:
          type: string
          enum:
            - applied
            - pending_until_flow_finishes
            - cancelled
          description: >-
            `applied`: the check has the new status.
            `pending_until_flow_finishes`: the override waits and applies when
            the person finishes the flow. `cancelled`: it waited and never
            applied (see `cancel_reason`).
          example: applied
        forced:
          type: boolean
          description: >-
            `true` when the override applied at once while the person was still
            in the flow.
          example: false
        reason:
          type: string
          nullable: true
          description: The `comment` sent with the request, or `null`.
          example: Document manually verified by compliance.
        requested_by:
          type: object
          nullable: true
          description: Who requested the override, or `null` when that is not known.
          properties:
            email:
              type: string
              format: email
              nullable: true
              description: >-
                Email of the console user, or `null` for API keys and the
                system.
              example: reviewer@example.com
            name:
              type: string
              nullable: true
              description: Display name of the requester, or `null`.
              example: Alex Reviewer
            type:
              type: string
              enum:
                - CONSOLE_USER
                - API_KEY
                - SYSTEM
              description: >-
                Who made the request: a console user, an API key, or Didit
                itself.
              example: CONSOLE_USER
        requested_at:
          type: string
          format: date-time
          description: When the override was requested.
          example: '2026-10-13T09:15:00Z'
        applied_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            When the check took the new status, or `null` while it waits or once
            it is cancelled.
          example: '2026-10-13T09:15:00Z'
        cancelled_at:
          type: string
          format: date-time
          nullable: true
          description: When a waiting override was cancelled, or `null`.
          example: null
        cancel_reason:
          type: string
          nullable: true
          enum:
            - cancelled_by_reviewer
            - replaced
            - check_changed
            - session_closed
            - null
          description: >-
            Why a waiting override never applied, or `null`.
            `cancelled_by_reviewer`: cancelled with the cancel endpoint.
            `replaced`: a newer override on the same check replaced it.
            `check_changed`: the person redid the check before finishing the
            flow. `session_closed`: the session left the flow before the person
            finished it (abandoned, expired, or decided mid-flow).
          example: null
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Your application's API key, from Developers -> API keys in the Business
        Console. The primary key has full access. A named key can be scoped:
        none, read or write per resource, limited to some workflows or to
        approved sessions, to a list of IP addresses, and to an expiry date. 401
        means the key is missing, wrong, revoked or expired; 403 means the key
        has no access to this resource or action, or the request came from an
        address outside its IP list; 404 on a session route means the session is
        outside the key's workflows or statuses. A key without media access
        receives image, video and PDF URLs as null, and a key without sessions
        write receives session links and tokens as null. See
        https://docs.didit.me/console/api-keys.

````

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