> ## 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 de mise à jour groupée du statut des dossiers

> Rouvrez, demandez des informations ou résolvez plusieurs dossiers en un seul appel avec Didit. Les échecs par dossier sont signalés sans interrompre le lot.



Prompt de l'API de mise à jour groupée du statut des dossiers
        Copier le prompt dans le presse-papiers



      
      

\<pre>

\`Update the status of several cases in one call through the Management API.

Endpoint:
POST https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/cases/bulk/status/

Authentication:
Use the x-api-key header with my Didit API key.

Request body:
\{
"case_uuids": ["<uuid>", "<uuid>"],   // required, at least 1
"status": "RESOLVED",                   // required: OPEN | AWAITING_USER | RESOLVED
"resolution": "FALSE_POSITIVE",         // required when status is RESOLVED
"note": "Bulk-cleared after review"      // optional
}

Behavior:
\- OPEN reopens each case, AWAITING_USER requests info, RESOLVED resolves with the given resolution/note.
\- Each case is evaluated independently inside its own transaction - a case blocked by an incomplete checklist or a missing required note is reported in "failures" without aborting the rest of the batch.

Example call:
curl -X POST "https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/cases/bulk/status/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"case_uuids": ["<uuid>"], "status": "RESOLVED", "resolution": "FALSE_POSITIVE"}'

Response 200: {"updated": 3, "failures": [{"case_uuid": "<uuid>", "detail": "Case has incomplete checklist items: ..."}]}

Failure modes:
\- 400 - status is RESOLVED without a resolution, or case_uuids is empty.
\- 401/403 - auth/permission errors.

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

Coller dans

Appliquez la même transition de statut à plusieurs dossiers à la fois, comme l'action groupée **Set Status** de la liste des dossiers. Les échecs sont signalés dossier par dossier : un dossier bloqué n'annule jamais le reste du lot.## Liens connexes- [Résoudre le dossier](https://docs.didit.me/fr/management-api/cases/resolve.md)
- [Lister les dossiers](https://docs.didit.me/fr/management-api/cases/list.md)


## OpenAPI

````yaml fr/openapi-25.json POST /v3/organization/{organization_id}/application/{application_id}/cases/bulk/status/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/organization/{organization_id}/application/{application_id}/cases/bulk/status/:
    post:
      tags:
        - Cases
      summary: Mettre à jour en masse le statut des dossiers
      description: >-
        Appliquez la même transition de statut à plusieurs dossiers en un seul
        appel : OPEN rouvre, AWAITING_USER demande des informations, RESOLVED
        résout (résolution requise). Chaque dossier est évalué indépendamment ;
        les échecs de critères de passage (checklist incomplète, note requise
        manquante) sont signalés par dossier sans interrompre le lot.
      operationId: bulk_update_case_status
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID de l'organisation.
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID de l'application.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - case_uuids
                - status
              properties:
                case_uuids:
                  type: array
                  items:
                    type: string
                    format: uuid
                  minItems: 1
                status:
                  type: string
                  enum:
                    - OPEN
                    - AWAITING_USER
                    - RESOLVED
                resolution:
                  type: string
                  enum:
                    - FALSE_POSITIVE
                    - VALID_THREAT
                    - INCONCLUSIVE
                    - REQUIREMENTS_NOT_MET
                    - REQUIREMENTS_SATISFIED
                  description: Requis lorsque le statut est RESOLVED.
                note:
                  type: string
                  nullable: true
            example:
              case_uuids:
                - c1a5e000-0000-4000-8000-000000000001
              status: RESOLVED
              resolution: FALSE_POSITIVE
      responses:
        '200':
          description: Résultats par dossier.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CaseBulkUpdateResult'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/organization/11111111-2222-3333-4444-555555555555/application/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/cases/bulk/status/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"case_uuids": ["c1a5e000-0000-4000-8000-000000000001"], "status": "RESOLVED", "resolution": "FALSE_POSITIVE"}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            client = Didit()

            result = client.cases.bulk_update_status(
                case_uuids=["c1a5e000-0000-4000-8000-000000000001"],
                status="RESOLVED",
                resolution="FALSE_POSITIVE",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            const didit = new Didit();

            const result = await didit.cases.bulkUpdateStatus({
              case_uuids: ["c1a5e000-0000-4000-8000-000000000001"],
              status: "RESOLVED",
              resolution: "FALSE_POSITIVE",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID\n// and DIDIT_APPLICATION_ID.\nclient := didit.NewClient()\n\nresult, err := client.Cases.BulkUpdateStatus(ctx, didit.CasesBulkUpdateStatusParams{\n\tCaseUUIDs:  []string{\"c1a5e000-0000-4000-8000-000000000001\"},\n\tStatus:     \"RESOLVED\",\n\tResolution: didit.Some(didit.CasesBulkUpdateStatusParamsResolution(\"FALSE_POSITIVE\")),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.CasesBulkUpdateStatusParams;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            Didit client = new Didit();


            var result =
            client.cases().bulkUpdateStatus(CasesBulkUpdateStatusParams.builder()
                    .caseUuids(List.of("c1a5e000-0000-4000-8000-000000000001"))
                    .status(CasesBulkUpdateStatusParams.Status.of("RESOLVED"))
                    .resolution(CasesBulkUpdateStatusParams.Resolution.of("FALSE_POSITIVE"))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            $didit = new DiditClient();

            $result = $didit->cases->bulkUpdateStatus([
                'case_uuids' => ['c1a5e000-0000-4000-8000-000000000001'],
                'status' => 'RESOLVED',
                'resolution' => 'FALSE_POSITIVE',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            didit = Didit::Client.new

            result = didit.cases.bulk_update_status(
              case_uuids: ["c1a5e000-0000-4000-8000-000000000001"],
              status: "RESOLVED",
              resolution: "FALSE_POSITIVE"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            using var client = new DiditClient();


            var result = await client.Cases.BulkUpdateStatusAsync(new
            CasesBulkUpdateStatusParams

            {
                CaseUuids = new string[] { "c1a5e000-0000-4000-8000-000000000001" },
                Status = "RESOLVED",
                Resolution = new CasesBulkUpdateStatusParamsResolution("FALSE_POSITIVE"),
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    CaseBulkUpdateResult:
      type: object
      properties:
        updated:
          type: integer
        failures:
          type: array
          items:
            type: object
            properties:
              case_uuid:
                type: string
                format: uuid
              detail:
                type: string
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.

````

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