> ## 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 के साथ एक ही कॉल में कई केस को फिर से खोलें, जानकारी माँगें या हल करें; प्रति केस विफलताएँ बैच को रोके बिना दिखाई जाती हैं।



Bulk Update Case Status API Prompt
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

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



      
      

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

एक ही स्थिति परिवर्तन को एक साथ कई केसों पर लागू करें, जो केसों की सूची की बल्क **Set Status** कार्रवाई जैसा ही है। विफलताएँ प्रति केस अलग से रिपोर्ट की जाती हैं, इसलिए एक अवरुद्ध केस बाकी बैच को कभी रोलबैक नहीं करता।## संबंधित- [केस हल करें](https://docs.didit.me/hi/management-api/cases/resolve.md)
- [केसों की सूची देखें](https://docs.didit.me/hi/management-api/cases/list.md)


## OpenAPI

````yaml hi/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। 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: केस की स्थिति को बल्क में अपडेट करें
      description: >-
        एक ही कॉल में कई केस पर समान स्थिति ट्रांज़िशन लागू करें: OPEN फिर से
        खोलता है, AWAITING_USER जानकारी का अनुरोध करता है, RESOLVED समाधान करता
        है (समाधान आवश्यक है)। प्रत्येक केस का स्वतंत्र रूप से मूल्यांकन किया
        जाता है; गेट विफलताएं (अपूर्ण चेकलिस्ट, अनुपलब्ध आवश्यक नोट) पूरे बैच को
        रोके बिना प्रति केस रिपोर्ट की जाती हैं।
      operationId: bulk_update_case_status
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: संगठन UUID।
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: एप्लिकेशन UUID।
      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: आवश्यक है जब स्थिति RESOLVED हो।
                note:
                  type: string
                  nullable: true
            example:
              case_uuids:
                - c1a5e000-0000-4000-8000-000000000001
              status: RESOLVED
              resolution: FALSE_POSITIVE
      responses:
        '200':
          description: प्रति-केस परिणाम।
          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: >-
        आपकी एप्लिकेशन की 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.