> ## 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 actualización masiva del estado de casos

> Didit permite reabrir, pedir información o resolver varios casos en una llamada; los fallos por caso se informan sin abortar el lote.



Prompt para la API de actualización masiva del estado de casos
        Copiar el prompt al portapapeles



      
      

\<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>



      
      

Pegar en

Aplica la misma transición de estado a muchos casos a la vez, igual que la acción masiva **Set Status** de la lista de casos. Los errores se informan por caso, por lo que un caso bloqueado nunca provoca la reversión del resto del lote.## Relacionado- [Resolver un caso](https://docs.didit.me/es/management-api/cases/resolve.md)
- [Listar casos](https://docs.didit.me/es/management-api/cases/list.md)


## OpenAPI

````yaml es/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 verificación de identidad. Autentícate con el encabezado 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: Actualizar en bloque el estado de casos
      description: >-
        Aplica la misma transición de estado a varios casos en una sola llamada:
        OPEN los reabre, AWAITING_USER solicita información y RESOLVED los
        resuelve (se requiere una resolución). Cada caso se evalúa de forma
        independiente; los fallos de control (checklist incompleta, falta una
        nota obligatoria) se informan por caso sin abortar el lote.
      operationId: bulk_update_case_status
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID de la organización.
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID de la aplicación.
      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: Obligatorio cuando status es RESOLVED.
                note:
                  type: string
                  nullable: true
            example:
              case_uuids:
                - c1a5e000-0000-4000-8000-000000000001
              status: RESOLVED
              resolution: FALSE_POSITIVE
      responses:
        '200':
          description: Resultados por caso.
          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 clave de API de tu aplicación, que encontrarás en Developers -> API
        keys en la Business Console. La clave principal tiene acceso completo.
        Una clave con nombre puede tener un alcance limitado: ninguno, lectura o
        escritura por recurso, limitada a algunos flujos o a sesiones aprobadas,
        a una lista de direcciones IP y a una fecha de caducidad. 401 significa
        que la clave es incorrecta, se revocó o expiró; 403 significa que no se
        envió ninguna clave, que la clave no tiene acceso a este recurso o
        acción, o que la solicitud provino de una dirección fuera de su lista de
        IP; 404 en una ruta de sesión significa que la sesión está fuera de los
        flujos o estados de la clave. Una clave sin acceso a contenido
        multimedia recibe las URL de imágenes, videos y PDF como null, y una
        clave sin permiso de escritura en sesiones recibe los enlaces y tokens
        de sesión como null. Consulta https://docs.didit.me/console/api-keys.

````

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