# India Court Case Search (`cloudastra-technologies/india-court-case-search`) Actor

Search Indian court cases by party name. Give a list of people or companies and get each case where the name appears as a party: CNR, case number, court, year, which side, and the other side.

- **URL**: https://apify.com/cloudastra-technologies/india-court-case-search.md
- **Developed by:** [Cloudastra Technologies](https://apify.com/cloudastra-technologies) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.50 / 1,000 court case founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## India Court Case Search

Search Indian court cases by party name. Give a list of people or companies,
and for each one get every case in our dataset where that name appears as a
party: the CNR, the case number, the year, the court, which side the name is
on, and who is on the other side.

Built for screening: checking a list of customers, vendors, borrowers or
counterparties for court cases before you go further with them.

### What you get

One row per case. A name with no case gets one free row saying so, if you
leave "Add a row for names with no case" switched on.

| Field | Meaning |
|---|---|
| `queryName` | The name you searched |
| `matchedName` | The party name as it appears in the case |
| `matchType` | `exact_name` or `partial_name` |
| `side` | `petitioner` or `respondent` |
| `opposingParty` | The other side. Empty when the court record has none |
| `cnr` | The case's national reference number |
| `caseNumber`, `caseType`, `caseYear` | As registered |
| `courtLevel`, `court`, `district`, `state` | Where the case is |
| `totalMatchesForName` | How many cases the name has in total, even when fewer rows were returned |
| `verifyUrl`, `verifyHint` | Where and how to check the case yourself: the eCourts portal for district cases, the Patna High Court site, or the Supreme Court of India site |
| `corpusAsOf` | The date of the data snapshot the row came from |

### Pricing

**$4.50 per 1,000 case rows.** You pay for cases returned. Nothing else.

- A name with **no case is free**. So is a row saying a name could not be
  searched this time
- **Maximum cases per name** caps what one common name can cost you. At the
  default of 50, a list of 100 names costs at most $22.50, and usually far
  less, because most names return a few cases or none
- Every row still tells you the **total** number of cases for that name, so a
  cap never hides how many there are
- If you set a maximum charge on the run, you get exactly as many rows as it
  covers. Nothing is billed beyond your limit

**Try it first** with five or ten names you already know about.

### Limitations, in plain language

**This is not all of India.** As of October 2026 the dataset holds about
690,000 cases:

- District courts in six states only: Madhya Pradesh, Uttar Pradesh, Bihar,
  Rajasthan, Punjab and Goa, mostly cases registered from 2024.
- The Patna High Court only, 1970 to 2023.
- The Supreme Court's reported judgments only, not its full list of cases.

**No match does not mean no cases.** It means the name is not in this dataset.
Every no-match row says so.

**A name is not a person.** The data holds no date of birth, address or ID
number. "Rajesh Kumar" matches thousands of different people. Use the results
to decide what to check, not as a finding about someone.

**Newest cases come first.** A name with many recent district cases can fill
your maximum before any older High Court or Supreme Court case appears. To see
those, choose the court level on its own.

**There is no link straight to a case.** None of the court sites offers one.
Each row tells you where to go and what to enter.

**The data is a snapshot, refreshed from time to time.** It is not live. Every
row carries the date of the snapshot it came from.

### Input

| Field | What it does |
|---|---|
| `names` | People or companies, one per entry. Up to 1,000 per run |
| `matchMode` | `exact` (recommended) matches the same words once titles, "Ltd" and "through" parts are removed. `strict` also matches longer names containing yours, so "Rajesh Kumar" finds "Rajesh Kumar Singh". It returns more, and more wrong matches |
| `courtLevels` | District courts, High Court, Supreme Court. Empty means all three |
| `states` | MP, BR, UP, RJ, PB, GA. Choosing any state leaves Supreme Court cases out, because they belong to no state |
| `yearFrom`, `yearTo` | Case years, 2010 or later. Leave empty to include older High Court and Supreme Court cases |
| `maxCasesPerName` | 1 to 500, default 50 |
| `includeGovernment` | Include cases where the match is a government party such as "State of UP". A name that is itself a government body is always searched |
| `includeNoMatches` | Add a free row for each name not found. On by default |

### FAQ

**Is a match the person I searched for?** Not necessarily. The data holds names
only. Treat a match as a lead to check, using the CNR or case number on the
court's own site.

**Why did a name I know has cases come back empty?** The dataset covers six
states' district courts, one High Court and the Supreme Court's reported
judgments. A case in another state or another High Court is not in it. Try
`strict` if the name may be recorded longer than you typed it.

**Why does "Union of India" return government cases when I left government
parties off?** Because the name you searched is itself a government body, so
it is always searched. The row says so in `governmentFilterLifted`.

**How fresh is the data?** See `corpusAsOf` on every row.

### Accuracy and support

Every row is drawn from publicly available court records. To report a row that
is wrong or out of date, email contact@cloudastra.co with the CNR or case
number and the run ID. For any other problem, use the Issues tab on this page.

### Data sources

District court cases come from the public eCourts services portal. High Court
and Supreme Court cases come from Dattam Labs, indian-high-court-judgments and
indian-supreme-court-judgments (AWS Open Data), CC-BY-4.0.

# Actor input Schema

## `names` (type: `array`):

People or companies, one per entry. Up to 1,000 per run. Repeated names are searched once.

## `matchMode` (type: `string`):

exact: the case party has the same words as your name, after titles, suffixes like Ltd, and 'through' or 'S/O' parts are removed. strict: every word of your name appears in the party name, so 'Rajesh Kumar' also finds 'Rajesh Kumar Singh'. strict returns more, and more wrong matches: 'Union of India' also finds 'Union Bank of India'.

## `courtLevels` (type: `array`):

Leave empty for all three. District courts cover 6 states, the High Court is Patna only, and Supreme Court rows are reported judgments only.

## `states` (type: `array`):

Leave empty for all. Choosing any state leaves Supreme Court cases out, because they belong to no state.

## `yearFrom` (type: `integer`):

Earliest case year, 2010 or later. Leave empty to search every year, including older High Court and Supreme Court cases.

## `yearTo` (type: `integer`):

Latest case year. Leave empty for no upper limit.

## `maxCasesPerName` (type: `integer`):

A common name can match thousands of cases. Every case row is charged, so this caps the cost per name. The total count is still reported on each row.

## `includeGovernment` (type: `boolean`):

Cases where your name is matched to a government party such as 'State of UP'. A name that is itself a government body, like 'Union of India', is always searched.

## `includeNoMatches` (type: `boolean`):

Writes one free row per name that was not found, saying what was searched. Not finding a name is not proof the name has no court cases.

## Actor input object example

```json
{
  "names": [
    "HDFC Bank",
    "Rajesh Kumar"
  ],
  "matchMode": "exact",
  "maxCasesPerName": 50,
  "includeGovernment": false,
  "includeNoMatches": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per case where a searched name appears as a party, and one free row per name that was not found. Only case rows are billed.

## `runSummary` (type: `string`):

Names searched, matched and not found, case rows returned, names capped at your maximum cases per name, the date of the data, and why the run stopped early, if it did. Not billed.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "names": [
        "HDFC Bank",
        "Rajesh Kumar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cloudastra-technologies/india-court-case-search").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "names": [
        "HDFC Bank",
        "Rajesh Kumar",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cloudastra-technologies/india-court-case-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "names": [
    "HDFC Bank",
    "Rajesh Kumar"
  ]
}' |
apify call cloudastra-technologies/india-court-case-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cloudastra-technologies/india-court-case-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0ISf5LftLp67vPeD1/builds/tQpDC9zviAmHdqjr5/openapi.json