> ## 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 stato funzionalità: approva o rifiuta un passaggio > Con Didit approvi, rifiuti o rimetti in revisione un singolo passaggio (es. OCR, AML, Prova di residenza), subito o a fine flusso. Prompt per l'aggiornamento dello stato di una funzionalità Copia il prompt negli appunti \

\`Approve, decline, or move a SINGLE verification step (feature) of a Didit session to review, now or once the person finishes the flow.

Endpoint:
PATCH https://verification.didit.me/v3/session/{session_id}/features/{node_id}/update-status/

Authentication:
x-api-key (client API key) or a user-auth token. Privilege: write:sessions.

Path parameters:
\- session_id (UUID) — KYC or KYB; Didit resolves it against both session types.
\- node_id — the workflow graph node ID of the step (e.g. feature_ocr_1, feature_liveness_1, feature_aml_1). Use the literal "default" for non-graph (single-step) workflows where the step has no node ID.

Request body:
\- new_status (string, required): one of "Approved", "Declined", "In Review". Must differ from the step's current status.
\- comment (string, optional): your reason, saved in the session's activity and returned as the override's reason.
\- feature_type (string, optional): which kind of step to target, for example "LIVENESS", "AML", "FACE_MATCH", "ID_VERIFICATION". Needed when node_id is "default" (non-graph workflows, where steps have no node ID). An unknown value returns 400 { "feature_type": ["Unknown feature_type '...'."] }.
\- defer_until_flow_finishes (boolean, optional, default false): while the person is still in the flow, wait and apply the override when the flow finishes instead of at once.

When the override applies:
\- Omitted or false: it applies at once. If the person is still in the flow it is recorded as forced=true.
\- true while the person is still in the flow (session Not Started, In Progress or Resubmitted, and not finished): it is stored as "pending_until_flow_finishes" and applies when the flow finishes, after the flow reaches its own decision.
\- true after the flow ended: it applies at once.
\- A waiting override is cancelled instead when the person redoes the step before finishing, a newer override on the same step replaces it, the session leaves the flow unfinished (abandoned, expired, decided mid-flow), or you cancel it with POST /v3/session/{session_id}/features/overrides/{override_id}/cancel/.

Which steps this works on:
Every per-step feature record: OCR/ID, Liveness, Face Match, NFC, AML, Proof of Address (POA), Phone, Email, Database Validation, Questionnaire, and the KYB registry / documents / key-people checks.

Difference vs update-status:
\- update-status changes the OVERALL session decision (Approved/Declined/Resubmitted).
\- THIS endpoint changes ONE step's status. A session that already has a decision keeps it. If the session has no decision yet and its workflow is waiting on exactly this step, applying the override completes the step: the workflow moves on and a status node can set the session decision (and fire status.updated).

Not allowed:
\- Standalone API sessions (session_type = API) return 400.

curl example — approve the ID/OCR step:
curl -X PATCH https://verification.didit.me/v3/session//features/feature_ocr_1/update-status/ \
-H "x-api-key: " \
-H "Content-Type: application/json" \
-d '{ "new_status": "Approved", "comment": "Document manually verified" }'

Response: { session_id, node_id, feature_type, new_status, override }.
\- node_id is the step's workflow node, or null for a step without a node ("default" in a non-graph workflow).
\- new_status is the step's stored status: the requested one once the override applied, the unchanged one while it waits.
\- override: { id, node_id, feature_type, feature_model, previous_status, new_status, state ("applied" | "pending_until_flow_finishes" | "cancelled"), forced, reason, requested_by { email, name, type }, requested_at, applied_at, cancelled_at, cancel_reason }.

Side effects:
\- Fires a data.updated webhook when the override applies (at once, or when the flow finishes). Nothing is sent while it waits or when it is cancelled.
\- Records the override in the session's activity as FEATURE_OVERRIDE_PENDING, FEATURE_OVERRIDE_APPLIED or FEATURE_OVERRIDE_CANCELLED, with who made it; the request's entry carries your comment. In the decision's reviews array these entries appear with new_status null, and the request's entry has your reason in comment.

Failure modes:
\- 400: new_status invalid or unchanged, unknown feature_type, or the session is a standalone API session.
\- 401: the scoped API key has expired.
\- 403: missing credentials (a wrong, revoked or expired key gets 401), or the caller lacks write:sessions (a scoped key needs decisions write).
\- 404: session not found, or no feature has the given node_id.

Related: list overrides with GET /v3/session/{session_id}/features/overrides/ (see /sessions-api/list-feature-overrides); cancel a waiting one with POST /v3/session/{session_id}/features/overrides/{override_id}/cancel/ (see /sessions-api/cancel-feature-override).

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

\
Incolla in ## Cosa faUna sessione di verifica è composta da singole **funzionalità** (passaggi): ID/OCR, Rilevamento della vitalità, Confronto facciale, AML, Prova di residenza, Telefono e così via. Questo endpoint ti consente di impostare lo stato di **una** di queste funzionalità su `Approved`, `Declined` o `In Review`.Usa [update-status](https://docs.didit.me/it/sessions-api/update-status.md) quando vuoi approvare, rifiutare o riaprire l'intera sessione. Usa **questo** endpoint quando vuoi registrare una decisione su un solo passaggio, per esempio per contrassegnare il passaggio Confronto facciale come `Declined` nel tuo flusso di revisione.Una sessione che ha già una decisione la mantiene: cambia solo il passaggio. Se la sessione non ha ancora una decisione e il suo workflow sta aspettando proprio questo passaggio, applicare la sovrascrittura completa il passaggio, come accadrebbe completandolo normalmente. Il workflow prosegue, vengono eseguiti i passaggi successivi e un nodo di stato può impostare la decisione della sessione e inviare un webhook `status.updated`.## Come indicare un passaggio con `node_id`Nei workflow basati su grafo ogni passaggio ha un `node_id` (per esempio `feature_ocr_1`, `feature_liveness_1`, `feature_aml_1`). Puoi trovarli nella [decisione della sessione](https://docs.didit.me/it/sessions-api/retrieve-session.md): ogni funzionalità in una decisione V3 contiene il proprio `node_id`.Per i workflow **non basati su grafo (a passaggio singolo)** la funzionalità sottostante non ha un ID nodo. Passa il valore letterale `default` come `nodeId` per indicarla. Poiché in questi workflow nessun passaggio ha un ID nodo, passa anche `feature_type` (per esempio `LIVENESS`, `AML` o `FACE_MATCH`) per indicare il passaggio desiderato. Un `feature_type` sconosciuto restituisce `400`.## Attendere che la persona completi il flussoPer impostazione predefinita la sovrascrittura viene applicata subito. Se la persona sta ancora percorrendo il flusso, viene modificato un passaggio di un flusso ancora in corso; in tal caso la sovrascrittura viene registrata con `forced: true`.Imposta `defer_until_flow_finishes: true` per attendere. Finché la sessione è `Not Started`, `In Progress` o `Resubmitted` e la persona non ha completato il flusso, la sovrascrittura viene memorizzata come `pending_until_flow_finishes`. Viene applicata quando la persona completa il flusso, dopo che il flusso ha raggiunto la propria decisione. Su una sessione il cui flusso è già terminato, viene applicata subito in entrambi i casi.Una sovrascrittura in attesa viene annullata anziché applicata quando:- la persona rifà il passaggio prima di completarlo (`check_changed`), - una sovrascrittura più recente sullo stesso passaggio la sostituisce (`replaced`), - la sessione esce dal flusso senza completarlo: abbandonata, scaduta o decisa a metà del flusso (`session_closed`), - la annulli con [Annulla la sovrascrittura della funzionalità](https://docs.didit.me/it/sessions-api/cancel-feature-override.md) (`cancelled_by_reviewer`).Il campo `override` della risposta indica cosa è successo: `state` è `applied` oppure `pending_until_flow_finishes`, e `applied_at` è valorizzato una volta applicata. Il campo `new_status` di primo livello è lo stato memorizzato del passaggio, quindi resta invariato mentre la sovrascrittura è in attesa. Usa [Elenca le sovrascritture delle funzionalità](https://docs.didit.me/it/sessions-api/list-feature-overrides.md) per vedere tutte le sovrascritture di una sessione e se la persona è ancora nel flusso.## Supporto KYC e KYBFunziona allo stesso modo per **Verifica degli utenti (KYC)** e **Verifica aziendale (KYB)**: Didit risolve il `sessionId` in entrambi i casi. I tipi di passaggio supportati includono ID/OCR, Rilevamento della vitalità, Confronto facciale, NFC, AML, Prova di residenza, Telefono, Email, Validazione su database, Questionario e i controlli KYB su registro, documenti e persone chiave.> [!NOTE] > > Le sessioni API autonome (quelle create tramite le API di verifica standalone, `session_type = API`) non possono avere lo stato delle singole funzionalità modificato: l'endpoint restituisce `400`.## Esempi> [tab] Approva un passaggio > > ```bash theme={null} > curl -X PATCH https://verification.didit.me/v3/session/4c5c7f3a-.../features/feature_ocr_1/update-status/ \ > -H "x-api-key: YOUR_API_KEY" \ > -H "Content-Type: application/json" \ > -d '{ > "new_status": "Approved", > "comment": "Document manually verified by compliance" > }' > ```> [tab] Rifiuta il passaggio Confronto facciale > > ```bash theme={null} > curl -X PATCH https://verification.didit.me/v3/session/4c5c7f3a-.../features/feature_face_match/update-status/ \ > -H "x-api-key: YOUR_API_KEY" \ > -H "Content-Type: application/json" \ > -d '{ > "new_status": "Declined" > }' > ```> [tab] Workflow a passaggio singolo (nodo predefinito) > > ```bash theme={null} > curl -X PATCH https://verification.didit.me/v3/session/4c5c7f3a-.../features/default/update-status/ \ > -H "x-api-key: YOUR_API_KEY" \ > -H "Content-Type: application/json" \ > -d '{ > "new_status": "In Review", > "feature_type": "LIVENESS" > }' > ```> [tab] Attendi che la persona completi il flusso > > ```bash theme={null} > curl -X PATCH https://verification.didit.me/v3/session/4c5c7f3a-.../features/feature_liveness_1/update-status/ \ > -H "x-api-key: YOUR_API_KEY" \ > -H "Content-Type: application/json" \ > -d '{ > "new_status": "Approved", > "comment": "Liveness retried with a reviewer present", > "defer_until_flow_finishes": true > }' > ```## Cosa succede dopo un aggiornamento- **Webhook**: un evento `data.updated` viene inviato quando la sovrascrittura viene applicata, subito oppure al termine del flusso. Nulla viene inviato mentre è in attesa o quando viene annullata. - **Attività**: ogni sovrascrittura viene registrata nell'attività della sessione come `FEATURE_OVERRIDE_PENDING`, `FEATURE_OVERRIDE_APPLIED` o `FEATURE_OVERRIDE_CANCELLED`, con l'autore (chiave API, utente o il sistema quando una sovrascrittura in attesa viene applicata). La voce della richiesta riporta il tuo `comment` come motivo. Nell'array `reviews` della [decisione della sessione](https://docs.didit.me/it/sessions-api/retrieve-session.md) queste voci compaiono con `new_status: null`, e la voce della richiesta riporta il tuo motivo in `comment`. - **Decisione della sessione**: una sessione che ha già una decisione la mantiene. Per cambiare la decisione finale, chiama [update-status](https://docs.didit.me/it/sessions-api/update-status.md) separatamente.## AutorizzazioneRichiede il privilegio `write:sessions`, con una chiave API del client (`x-api-key`) o un header di autorizzazione utente. Una chiave API con ambito limitato richiede l'accesso in scrittura alle decisioni.## Correlati- [Aggiorna lo stato della sessione](https://docs.didit.me/it/sessions-api/update-status.md): modifica la decisione complessiva della sessione. - [Aggiorna lo stato di un riscontro AML](https://docs.didit.me/it/sessions-api/update-aml-hit-status.md): verifica le singole corrispondenze AML. - [Recupera la sessione](https://docs.didit.me/it/sessions-api/retrieve-session.md): recupera la decisione (e il `node_id` di ciascuna funzionalità). - [Webhook](https://docs.didit.me/it/integration/webhooks.md): iscriviti a `data.updated`. - [Elenca le sovrascritture delle funzionalità](https://docs.didit.me/it/sessions-api/list-feature-overrides.md): tutte le sovrascritture di una sessione e il loro stato. - [Annulla la sovrascrittura della funzionalità](https://docs.didit.me/it/sessions-api/cancel-feature-override.md): interrompe una sovrascrittura in attesa prima che venga applicata. ## OpenAPI ````yaml it/openapi-25.json PATCH /v3/session/{sessionId}/features/{nodeId}/update-status/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API di verifica dell'identità. Autenticati con l'intestazione x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/session/{sessionId}/features/{nodeId}/update-status/: patch: tags: - Sessions summary: Aggiorna lo stato di una singola funzionalità (passaggio) description: >- Imposta lo stato di una singola funzionalità di verifica (passaggio) all'interno di una sessione. Seleziona la funzionalità tramite il suo `nodeId` nel grafo del workflow. Nei workflow senza grafo, i cui passaggi non hanno nodi, usa `default` e passa anche `feature_type` per indicare a quale passaggio ti riferisci. Funziona sia per le sessioni di Verifica degli utenti (KYC) sia per quelle di Verifica aziendale (KYB) e per ogni tipo di passaggio: ID/OCR, Rilevamento della vitalità, Confronto facciale, NFC, AML, Prova di residenza, Verifica telefonica, Verifica email, Validazione su database, Questionari e i controlli KYB su registro / documenti / persone chiave. Questo endpoint **non** è disponibile per le sessioni API standalone (`session_type = API`). `new_status` deve essere `Approved`, `Declined` o `In Review` e deve differire dallo stato attuale della funzionalità. **Quando viene applicato l'override.** Senza `defer_until_flow_finishes` (o con `false`), l'override viene applicato immediatamente, come sempre; quando la persona è ancora nel flusso, viene registrato come `forced`. Con `defer_until_flow_finishes: true` mentre la persona è ancora nel flusso (la sessione è `Not Started`, `In Progress` o `Resubmitted` e non è terminata), l'override viene memorizzato come `pending_until_flow_finishes` e applicato al termine del flusso, dopo che quest'ultimo ha raggiunto la propria decisione. Su una sessione il cui flusso è già terminato, viene applicato immediatamente in entrambi i casi. Un override in attesa viene invece annullato se la persona ripete il passaggio prima di terminare, se un override più recente sullo stesso controllo lo sostituisce, se la sessione abbandona il flusso prima del termine (abbandonata, scaduta o decisa a metà flusso), oppure se lo annulli con `POST /v3/session/{sessionId}/features/overrides/{overrideId}/cancel/`. Visualizza gli override di una sessione con `GET /v3/session/{sessionId}/features/overrides/`. **Effetto sulla sessione.** Una sessione che ha già una decisione la mantiene: cambia solo il controllo. Quando la sessione non ha ancora una decisione e il suo workflow è in attesa proprio di questo passaggio, l'applicazione dell'override completa il passaggio: il workflow prosegue, i passaggi successivi vengono eseguiti e un nodo di stato può impostare la decisione della sessione e attivare `status.updated`. **Webhook e attività.** Un webhook `data.updated` viene inviato quando l'override viene applicato (immediatamente o al termine del flusso), mai mentre è in attesa o quando viene annullato. Ogni override viene registrato nell'attività della sessione come `FEATURE_OVERRIDE_PENDING`, `FEATURE_OVERRIDE_APPLIED` o `FEATURE_OVERRIDE_CANCELLED`, insieme a chi lo ha effettuato; la voce della richiesta include il tuo `comment`. Autenticati con la tua chiave API (`x-api-key`) o con un'intestazione di autorizzazione utente che include il privilegio `write:sessions`; una chiave API con ambito limitato necessita dell'accesso in scrittura alle decisioni. operationId: patch_v3_session_update_feature_status parameters: - in: path name: sessionId required: true description: >- UUID della sessione di verifica. Accetta sia ID di sessione utente (KYC) sia ID di sessione aziendale (KYB): il servizio risolve l'ID per entrambi i tipi di sessione. schema: type: string format: uuid example: 11111111-2222-3333-4444-555555555555 - in: path name: nodeId required: true description: >- ID del nodo del grafo del workflow della funzionalità da aggiornare (ad esempio `feature_ocr_1`). Usa il valore letterale `default` per i workflow non basati su grafo (a singolo passaggio) in cui la funzionalità non ha un ID nodo. schema: type: string example: feature_ocr_1 requestBody: required: true content: application/json: schema: type: object required: - new_status properties: new_status: type: string description: >- Stato di destinazione per questa funzionalità. Deve differire dal valore attuale. enum: - Approved - Declined - In Review example: Approved comment: type: string description: >- Nota opzionale a testo libero registrata nella traccia di revisione della sessione per questa modifica della funzionalità. example: Document manually verified by compliance. feature_type: type: string enum: - ID_VERIFICATION - OCR - OCR_BACK - NFC - LIVENESS - FACE - AGE_ESTIMATION - AGE_VERIFICATION - FACE_SEARCH - FACE_MATCH - IP_ANALYSIS - AML - PHONE - PHONE_VERIFICATION - EMAIL - EMAIL_VERIFICATION - POA - PROOF_OF_ADDRESS - DATABASE_VALIDATION - DATA_VALIDATION - QUESTIONNAIRE - DOCUMENT_AI - KYB_REGISTRY - KYB_DOCUMENTS - KYB_KEY_PEOPLE - BANK_VERIFICATION - GEOLOCATION description: >- A quale tipo di passaggio puntare. Necessario sui workflow non a grafo (`nodeId` = `default`), dove i passaggi non condividono alcun nodo; facoltativo negli altri casi. Un valore sconosciuto restituisce `400`. example: LIVENESS defer_until_flow_finishes: type: boolean default: false description: >- Mentre la persona è ancora nel flusso, memorizza l'override come `pending_until_flow_finishes` e applicalo al termine del flusso, anziché immediatamente. Se omesso o impostato su `false`, l'override viene applicato immediatamente. Su una sessione il cui flusso è già terminato, viene comunque applicato immediatamente. example: false examples: Apply Now: summary: Approva subito il passaggio ID value: new_status: Approved comment: Document manually verified by compliance. Wait For The Flow: summary: >- Approva il passaggio di rilevamento della vitalità non appena la persona completa il flusso value: new_status: Approved comment: Liveness retried with a reviewer present. defer_until_flow_finishes: true Non-graph Workflow: summary: >- Indirizza il passaggio di rilevamento della vitalità di un workflow senza nodi (nodeId = default) value: new_status: In Review feature_type: LIVENESS responses: '200': description: >- L'override è stato registrato. `new_status` è lo stato del controllo così come memorizzato: quello richiesto una volta applicato l'override, quello invariato mentre attende il completamento del flusso. `override` indica quale delle due situazioni si è verificata. content: application/json: schema: type: object properties: session_id: type: string format: uuid node_id: type: string nullable: true description: >- Il nodo del workflow del passaggio aggiornato, oppure `null` per un passaggio senza nodo (il percorso `default` in un workflow non a grafo). example: feature_ocr_1 feature_type: type: string description: >- Nome del modello della funzionalità aggiornata (ad es. `KYC`, `Face`, `FaceMatch`, `AML`, `POA`). example: KYC new_status: type: string description: >- Lo stato memorizzato del controllo: quello richiesto una volta applicato l'override, quello invariato mentre l'override è in attesa che il flusso termini. example: Approved override: $ref: '#/components/schemas/FeatureStatusOverride' required: - session_id - node_id - feature_type - new_status - override examples: Applied: summary: L'override applicato immediatamente value: session_id: 3fa85f64-5717-4562-b3fc-2c963f66afa6 node_id: feature_ocr_1 feature_type: KYC new_status: Approved override: id: 7c9e6679-7425-40de-944b-e07fc1f90ae7 node_id: feature_ocr_1 feature_type: '' feature_model: KYC previous_status: In Review new_status: Approved state: applied forced: false reason: Document manually verified by compliance. requested_by: email: reviewer@example.com name: Alex Reviewer type: CONSOLE_USER requested_at: '2026-10-13T09:15:00Z' applied_at: '2026-10-13T09:15:00Z' cancelled_at: null cancel_reason: null Waiting For The Flow: summary: >- defer_until_flow_finishes mentre la persona è ancora nel flusso value: session_id: 3fa85f64-5717-4562-b3fc-2c963f66afa6 node_id: feature_liveness_1 feature_type: Face new_status: Declined override: id: 9b2f4c1e-8d3a-4e5f-a6b7-c8d9e0f1a2b3 node_id: feature_liveness_1 feature_type: '' feature_model: Face previous_status: Declined new_status: Approved state: pending_until_flow_finishes 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: null cancel_reason: null '400': description: >- Errore di validazione. Restituito quando `new_status` non è valido o non è cambiato, quando `feature_type` è sconosciuto, oppure quando la sessione è una sessione API autonoma. content: application/json: examples: Same Status: summary: new_status corrisponde allo stato attuale value: new_status: - The new status is the same as the current status. API Session: summary: >- Lo stato della funzionalità non può essere modificato nelle sessioni API autonome value: - Cannot change feature status for API sessions. Unknown feature_type: summary: feature_type non è un tipo di passaggio noto value: feature_type: - Unknown feature_type 'SELFIE'. '401': description: La chiave API con ambito è scaduta. content: application/json: examples: Expired API Key: summary: Chiave API con ambito oltre la sua data di scadenza value: detail: This API key has expired. '403': description: Credenziali mancanti o autorizzazioni insufficienti. content: application/json: examples: Invalid Credentials: summary: x-api-key mancante o non valida value: detail: >- Authentication credentials were not provided or are invalid. Missing Privilege: summary: La chiave API non dispone dell'autorizzazione write:sessions value: detail: You do not have permission to perform this action. Scoped Key Without Access: summary: >- Chiave API con ambito priva di accesso in scrittura alle decisioni value: detail: This API key has no write access to decisions. '404': description: >- La sessione non è stata trovata o non include alcuna funzionalità con il `nodeId` specificato. content: application/json: examples: Session Not Found: summary: session_id sconosciuto value: detail: Session not found. Feature Not Found: summary: Nessuna funzionalità per questo node_id value: detail: >- No feature found with node_id 'feature_ocr_1' in this session. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: |- curl -X PATCH \ https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/features/feature_ocr_1/update-status/ \ -H 'x-api-key: YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{ "new_status": "Approved", "comment": "Document manually verified by compliance." }' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.sessions.update_feature_status( "11111111-2222-3333-4444-555555555555", "feature_ocr_1", new_status="Approved", comment="Document manually verified by compliance.", ) 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.updateFeatureStatus( "11111111-2222-3333-4444-555555555555", "feature_ocr_1", { new_status: "Approved", comment: "Document manually verified by compliance.", }, ); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Sessions.UpdateFeatureStatus(ctx, \"11111111-2222-3333-4444-555555555555\", \"feature_ocr_1\", didit.SessionsUpdateFeatureStatusParams{\n\tNewStatus: \"Approved\",\n\tComment: didit.String(\"Document manually verified by compliance.\"),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: >- import me.didit.Didit; import me.didit.types.SessionsUpdateFeatureStatusParams; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.sessions().updateFeatureStatus("11111111-2222-3333-4444-555555555555", "feature_ocr_1", SessionsUpdateFeatureStatusParams.builder() .newStatus(SessionsUpdateFeatureStatusParams.NewStatus.of("Approved")) .comment("Document manually verified by compliance.") .build()); System.out.println(result); - lang: php label: PHP source: >- sessions->updateFeatureStatus('11111111-2222-3333-4444-555555555555', 'feature_ocr_1', [ 'new_status' => 'Approved', 'comment' => 'Document manually verified by compliance.', ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.sessions.update_feature_status( "11111111-2222-3333-4444-555555555555", "feature_ocr_1", new_status: "Approved", comment: "Document manually verified by compliance." ) 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.UpdateFeatureStatusAsync("11111111-2222-3333-4444-555555555555", "feature_ocr_1", new SessionsUpdateFeatureStatusParams { NewStatus = "Approved", Comment = "Document manually verified by compliance.", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: FeatureStatusOverride: type: object description: >- Un override dello stato di un controllo (funzionalità) eseguito con `PATCH /v3/session/{sessionId}/features/{nodeId}/update-status/`: cosa modifica, se è stato applicato o è ancora in attesa che la persona completi il flusso, chi lo ha richiesto e perché. 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: Identificatore dell'override. Passalo all'endpoint di annullamento. example: 7c9e6679-7425-40de-944b-e07fc1f90ae7 node_id: type: string description: >- Il nodo del workflow indicato dalla richiesta (`default` per un passaggio privo di nodo). example: feature_ocr_1 feature_type: type: string description: >- Il `feature_type` passato dalla richiesta, oppure una stringa vuota se non ne è stato passato alcuno. example: '' feature_model: type: string description: >- Il tipo di controllo che è stato ignorato manualmente, ad esempio `KYC`, `Face`, `AML` o `GeolocationCheck`. example: KYC previous_status: type: string enum: - Not Finished - Approved - Declined - In Review - Resub Requested description: Lo stato del controllo al momento della richiesta dell'override. example: In Review new_status: type: string enum: - Approved - Declined - In Review description: Lo stato impostato dall'override. example: Approved state: type: string enum: - applied - pending_until_flow_finishes - cancelled description: >- `applied`: il controllo ha il nuovo stato. `pending_until_flow_finishes`: l'override resta in attesa e viene applicato quando la persona completa il flusso. `cancelled`: è rimasto in attesa e non è mai stato applicato (vedi `cancel_reason`). example: applied forced: type: boolean description: >- `true` quando l'override è stato applicato immediatamente mentre la persona si trovava ancora nel flusso. example: false reason: type: string nullable: true description: Il `comment` inviato con la richiesta, oppure `null`. example: Document manually verified by compliance. requested_by: type: object nullable: true description: Chi ha richiesto l'override, o `null` quando non è noto. properties: email: type: string format: email nullable: true description: >- Email dell'utente della console, oppure `null` per le chiavi API e il sistema. example: reviewer@example.com name: type: string nullable: true description: Nome visualizzato del richiedente, oppure `null`. example: Alex Reviewer type: type: string enum: - CONSOLE_USER - API_KEY - SYSTEM description: >- Chi ha effettuato la richiesta: un utente della console, una chiave API o Didit stessa. example: CONSOLE_USER requested_at: type: string format: date-time description: Quando è stato richiesto l'override. example: '2026-10-13T09:15:00Z' applied_at: type: string format: date-time nullable: true description: >- Data e ora in cui il controllo ha assunto il nuovo stato, oppure `null` mentre è in attesa o una volta annullato. example: '2026-10-13T09:15:00Z' cancelled_at: type: string format: date-time nullable: true description: Quando un override in attesa è stato annullato, oppure `null`. example: null cancel_reason: type: string nullable: true enum: - cancelled_by_reviewer - replaced - check_changed - session_closed - null description: >- Il motivo per cui un override in attesa non è mai stato applicato, oppure `null`. `cancelled_by_reviewer`: annullato con l'endpoint di annullamento. `replaced`: sostituito da un override più recente sullo stesso controllo. `check_changed`: la persona ha ripetuto il controllo prima di completare il flusso. `session_closed`: la sessione è uscita dal flusso prima che la persona lo completasse (abbandonata, scaduta o decisa a metà flusso). example: null securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- La chiave API della tua applicazione, da Developers -> API keys nella Business Console. La chiave primaria ha accesso completo. Una chiave con nome può avere un ambito definito: nessuno, lettura o scrittura per risorsa, limitata ad alcuni workflow o a sessioni approvate, a un elenco di indirizzi IP e a una data di scadenza. 401 indica che la chiave è errata, revocata o scaduta; 403 indica che non è stata inviata alcuna chiave, che la chiave non ha accesso a questa risorsa o azione, oppure che la richiesta proviene da un indirizzo non incluso nel suo elenco IP; 404 su una route di sessione indica che la sessione non rientra nei workflow o negli stati previsti dalla chiave. Una chiave senza accesso ai media riceve gli URL di immagini, video e PDF come null, e una chiave senza permessi di scrittura sulle sessioni riceve link e token di sessione come null. Consulta https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.