# India Company Registry (`civicdataforge/india-company-registry`) Actor

- **URL**: https://apify.com/civicdataforge/india-company-registry.md
- **Developed by:** [Bryan](https://apify.com/civicdataforge) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## India Company Registry Evidence — CIN Change Monitoring

Version 0.3 adds exact bulk lookup for up to 5,000 CINs and registered names, adaptive
pagination when OGD returns smaller pages than requested, transparent CIN decomposition
(listing prefix, activity code, state code, incorporation year, ownership code, registration
number), deterministic completeness and anomaly flags, and bounded concurrency.

The quality fields are evidence aids, not opaque “AI risk scores.” Every flag has a visible
rule, every source request is sanitized, every record has a stable fingerprint, and every run
has a recomputable receipt. This Actor does not claim director, charge, GST, PAN, filing, or
financial-statement coverage because those fields are not in the selected official OGD
resource. Lawful enrichment can be added only from an owner-approved public API or a
caller-provided licensed source; protected MCA or third-party pages are not bypassed.

Official Ministry of Corporate Affairs company master data distributed through India's Open
Government Data platform. This Actor adds a CIN-centered evidence and change layer without claiming
that a periodic source snapshot is real-time MCA status.

### What is different

Every company row includes:

- `entity_key` anchored to the published CIN;
- deterministic `record_fingerprint` over stable source content;
- `change_type` of `uncompared`, `new`, `changed`, or `unchanged` against caller-supplied prior CIN
  fingerprints;
- exact official resource and sanitized request URLs, fetch time, query hash, and explicit source
  status; and
- the original OGD record in `raw`.

`RUN-RECEIPT` contains the source and query hashes, page count, matched pool, fetched and pushed counts,
snapshot digest, partial-source warning, comparison counts, limitations, and a canonical receipt hash.

### Query fields

Use exact server-side filters for `cin`, `state`, `status`, `companyClass`, `category`, and `roc`.
`nameContains` is applied within that filtered stream because the OGD endpoint does not provide a
general substring operator. `maxRecords` bounds results from 1 to 50,000.

For reliable volume, supply a caller-owned free `data.gov.in` `apiKey`. It is secret input, is sent
only to the official API, and is stripped from request evidence and output.

### Change comparison

Pass prior receipt items:

```json
{
  "state": "Delhi",
  "maxRecords": 100,
  "previousFingerprints": [
    { "cin": "U00001DL2020PTC000001", "record_fingerprint": "sha256:..." }
  ],
  "onlyChanges": true
}
```

The Actor compares only CINs returned by the current bounded query. It does not call missing CINs
"removed" because a limit, changed filter, rate limit, or partial scan could create a false removal.

### Interpretation boundaries

- OGD is a periodic official master snapshot, not intraday MCA verification.
- A changed fingerprint says published source content changed; it does not explain why.
- Partial scans remain useful but every row and the run receipt say `partial_error`.
- This is evidence for research, KYB, and monitoring—not an automatic KYC, AML, credit, eligibility,
  ownership, or legal-status decision.

Source attribution: Ministry of Corporate Affairs, Government of India, via `data.gov.in`. See the
[Government Open Data License — India](https://ap.data.gov.in/godl). This Actor is not affiliated with
or endorsed by the Government of India.

# Actor input Schema

## `nameContains` (type: `string`):

Case-insensitive name substring within the server-filtered pool. Pair with a state or class filter for bounded scans.

## `cin` (type: `string`):

Exact Corporate Identification Number.

## `cins` (type: `array`):

Up to 5,000 exact CINs. Each is looked up independently and returned with per-record evidence.

## `companyNameExact` (type: `string`):

Exact official registered company-name filter.

## `companyNames` (type: `array`):

Up to 5,000 exact registered names. Combine with CINs; ambiguous keyword matching is deliberately excluded.

## `maxConcurrency` (type: `integer`):

Parallel exact lookups from 1 to 8. Lower this if the caller-owned OGD key is rate-limited.

## `includeLei` (type: `boolean`):

For each returned CIN, query the official public GLEIF API for an exact registered-identifier match and attach LEI identity, validation, renewal, and address evidence. No fuzzy match is accepted.

## `state` (type: `string`):

Exact official registered-state filter.

## `status` (type: `string`):

Exact official company-status filter.

## `companyClass` (type: `string`):

Exact official class filter.

## `category` (type: `string`):

Exact official category filter.

## `roc` (type: `string`):

Exact Registrar of Companies filter.

## `maxRecords` (type: `integer`):

Bounded result limit from 1 to 50,000.

## `previousFingerprints` (type: `array`):

Optional caller-controlled prior receipt items: \[{"cin":"...","record\_fingerprint":"sha256:..."}]. Returned CINs become new, changed, or unchanged. Removed records are never inferred from a bounded query.

## `onlyChanges` (type: `boolean`):

Requires previousFingerprints. Unchanged returned records are omitted.

## `apiKey` (type: `string`):

Optional caller-owned key for a private quota. Never returned in records or receipts.

## Actor input object example

```json
{
  "nameContains": "Tata",
  "cins": [],
  "companyNames": [],
  "maxConcurrency": 5,
  "includeLei": false,
  "maxRecords": 25,
  "previousFingerprints": [],
  "onlyChanges": false
}
```

# Actor output Schema

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

No description

## `runReceipt` (type: `string`):

No description

# 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 = {
    "nameContains": "Tata",
    "maxRecords": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("civicdataforge/india-company-registry").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 = {
    "nameContains": "Tata",
    "maxRecords": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("civicdataforge/india-company-registry").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "nameContains": "Tata",
  "maxRecords": 25
}' |
apify call civicdataforge/india-company-registry --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=civicdataforge/india-company-registry",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/P5CCMgThEnbdVFQ0P/builds/uhrhMMaKzlwuLe55e/openapi.json