# India Company Data API (MCA) – CIN Lookup, Directors & Email (`data_daemon/india-company-data`) Actor

$3 per 1,000 companies, directors included | Look up Indian companies by CIN or name: status, incorporation date, capital, RoC, registered office, company email and website, compliance flags and the board of directors with DIN. Watchlist mode returns only companies that changed.

- **URL**: https://apify.com/data_daemon/india-company-data.md
- **Developed by:** [Daemon Data](https://apify.com/data_daemon) (community)
- **Categories:** Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 company data API: CIN lookup, directors and company email

**India Company Data API (MCA)** looks up Indian companies by **CIN or company name** and returns the public register record as JSON, CSV or Excel. It is for KYB and onboarding teams, lenders, B2B sales and data teams, and due-diligence analysts. Each row has the **status, incorporation date, type, RoC, authorised and paid-up capital, registered office, the company's email and website, compliance flags** (ACTIVE compliance, CIRP) and the **board of directors with DIN, designation and appointment date**. It costs **$3 per 1,000 companies with directors included**. On 11 November 2026 a run returned 204 companies in 8 minutes with zero failed lookups; 80% carried a company email and 86% a current board.

A **watchlist mode** turns a list of CINs into a monitoring feed: scheduled runs return, and charge, only the companies whose record changed.

#### What you can do with it

| You need | Input | You get |
|---|---|---|
| Verify a business before onboarding it | its CIN | Status, class, capital, registered office, directors |
| Enrich a CRM or lead list | a column of CINs or company names | Email, website, address, PIN code, activity, capital per company |
| Find a company's CIN | its registered name | CIN plus the full record, with a match label |
| Monitor customers, suppliers or borrowers | the same CIN list on a schedule, `onlyChanged: true` | Only companies whose status, capital, address, filings or board changed |
| Map a board | a CIN, `includeRelatedCompanies: true` | Directors, their number of directorships, and companies that share a director |

### How to look up an Indian company by CIN or name

1. Open the **Input** tab. Paste CINs into **CINs**, or registered names into **Company names** (or both).
2. Click **Start**. Leave both empty to see three sample companies first.
3. Open the **Output** tab: one row per company. Download as JSON, CSV, Excel or HTML, or read it through the API.
4. For monitoring, turn on **Watchlist mode** and add a schedule (Apify Console → Schedules).

Names are matched from the start of the registered name, so `Tata Consultancy Services` finds the company and `TCS` does not. Each row says how it matched (`matchType`): `cin`, `exact`, `name` (same name without Private / Limited) or `partial` (the registered name starts with your text: check it). A CIN is always the safer key.

### Input

| Field | What it does |
|---|---|
| `cins` | CINs to look up. Lines or URLs that contain a CIN work too. |
| `companyNames` | Registered names to resolve to a CIN |
| `matchesPerName` | Companies returned per name, 1 to 6 (default 1: the best match) |
| `includeDirectors` | Board and signatories (default on, no extra charge) |
| `includeRelatedCompanies` | Companies that share a director |
| `onlyChanged`, `stateName` | Watchlist mode and the name of its memory |
| `maxItems` | Cap for test runs |
| `proxyConfiguration` | Keep Apify Proxy on (default). See the FAQ. |

```json
{
    "cins": ["L17110MH1973PLC019786", "L85110KA1981PLC013115"],
    "companyNames": ["Tata Consultancy Services Limited"],
    "includeDirectors": true
}
```

### Output

```json
{
    "cin": "L22210MH1995PLC084781",
    "name": "TATA CONSULTANCY SERVICES LIMITED",
    "url": "https://www.instafinancials.com/company/tata-consultancy-services-limited-L22210MH1995PLC084781",
    "status": "Active",
    "registrationDate": "1995-01-19",
    "registrationNumber": "84781",
    "companyType": "Public Limited",
    "companyTypeCode": "PLC",
    "listed": true,
    "roc": "RoC Mumbai I",
    "state": "Maharashtra",
    "cinStateCode": "MH",
    "category": "Company limited by shares",
    "subCategory": "Indian Non-Government Company",
    "companyClass": "Public Company",
    "activity": "Publishing; Printing And Reproduction Of Recorded Media",
    "nicCode": "22210",
    "authorizedCapitalInr": 5650750000,
    "paidUpCapitalInr": 3618087518,
    "email": "yn.sheth@tcs.com",
    "website": "https://www.tcs.com",
    "registeredAddress": "9TH FLOOR, NIRMAL BUILDING NARIMAN POINT, NA, MUMBAI, Maharashtra 400021, India",
    "pincode": "400021",
    "lastAgmDate": "2026-06-09",
    "lastFinancialsDate": "2026-03-31",
    "activeCompliance": "ACTIVE compliant",
    "cirpStatus": null,
    "filingStatus": null,
    "sourceUpdatedAt": "2026-11-05",
    "directorsCount": 9,
    "directors": [
        {"name": "CHANDRASEKARAN NATARAJAN", "din": "00121863", "designation": "Director", "appointmentDate": "2017-06-16", "totalDirectorships": 16, "disqualified": false, "dinDeactivated": false}
    ],
    "signatories": [
        {"name": "...", "designation": "Company Secretary", "appointmentDate": "...", "isKmp": null}
    ],
    "query": "Tata Consultancy Services Limited",
    "queryType": "name",
    "matchType": "exact",
    "source": "MCA company register (via instafinancials.com public company pages)",
    "scrapedAt": "2026-11-11T11:13:00.000Z"
}
```

#### Fields

| Field | Notes |
|---|---|
| `cin`, `name`, `status`, `registrationDate`, `registrationNumber` | Identity and register status (Active, Strike Off, Amalgamated, Under CIRP, Converted to LLP and so on) |
| `companyType`, `companyTypeCode`, `listed`, `state`, `cinStateCode`, `nicCode` | Decoded from the CIN |
| `roc`, `category`, `subCategory`, `companyClass`, `activity` | From the register record |
| `authorizedCapitalInr`, `paidUpCapitalInr` | Whole rupees |
| `email`, `website` | The company's own contact on record. Null when the register copy has none. |
| `registeredAddress`, `pincode` | Registered office |
| `lastAgmDate`, `lastFinancialsDate` | Latest AGM and balance sheet on file; null for companies that have not filed yet |
| `activeCompliance`, `cirpStatus`, `filingStatus` | Compliance flags when the register shows them |
| `directors[]` | `name`, `din`, `designation`, `appointmentDate`, `totalDirectorships`, `disqualified` (section 164(2)), `dinDeactivated` |
| `signatories[]` | Company secretary, CFO and other signing officers: `name`, `designation`, `appointmentDate`, `isKmp` |
| `relatedCompanies[]` | On request: `name`, `status`, `state`, `commonDirectors` |
| `sourceUpdatedAt` | When the source last refreshed the company from the register. Null for very new companies, whose email and appointment dates can still be empty. |
| `query`, `queryType`, `matchType` | What you asked for and how it matched |
| `changeType`, `changedFields` | Watchlist mode only |

The run's `RUN-SUMMARY` record (key-value store) lists every CIN or name that returned nothing, with the reason, so a pipeline can retry or flag them.

### How much does Indian company data cost?

**$0.003 per company** ($3 per 1,000) plus $0.001 per run. Directors, signatories and related companies are included. CINs and names that are not found are free, and in watchlist mode unchanged companies are free.

| Job | Companies charged | Cost |
|---|---|---|
| Sample (three companies) | 3 | $0.01 |
| Verify 100 CINs | 100 | $0.30 |
| Enrich a list of 5,000 companies | 5,000 | $15 |
| Watch 2,000 companies daily | the full 2,000 on the first run, then only the ones that changed | $6 once, then cents a day |

Apify's free plan includes $5 of monthly credit, enough for about 1,600 companies.

### Tips

- Expect about 25 companies a minute: 1,000 companies take about 40 minutes, so raise the run timeout for long lists (a run that reaches its timeout keeps what it has and says so).
- Use **CINs** whenever you have them: exact, and one request less per company than a name.
- For a group, search its first word with `matchesPerName: 6` (`Zomato` returns up to six Zomato companies) and keep the rows you want.
- A watchlist remembers companies under `stateName`. Use one name per list; a new name starts from scratch and returns everything once.
- Very new companies (registered in the last few weeks) are present with status, capital and address, but their email is often still empty at the source.
- LLPs (LLPIN such as `AAB-1234`) are not covered yet.
- For **newly registered companies by date** (a daily lead feed), use the sibling Actor [India New Company Registrations](https://apify.com/data_daemon/india-new-company-registrations) and pass its CINs here for emails and directors.

### FAQ

#### Where does the data come from?

From the Ministry of Corporate Affairs (MCA) company register as shown on the public company pages of InstaFinancials, a company-information site that compiles MCA filings. `sourceUpdatedAt` shows how recent each record is. It is a copy of the register, not the MCA portal itself: for a legally binding extract use MCA's own certified copies.

#### Is there an API for MCA company master data?

This Actor works as one: send a list of CINs or names, get the master data and board back as JSON. It does not call an MCA API; it reads a public copy of the register (see above). For certified extracts use MCA's own services.

#### Does it return directors' phone numbers or personal emails?

No. Directors are returned with name, DIN, designation and appointment date, which are public-record governance data. The only contact fields are the company's own email and website.

#### Why should I keep the proxy on?

The source serves a limited number of pages per IP address. The Actor spreads a list over many addresses through Apify Proxy (datacenter addresses are enough, and they are included in the price). With the proxy off, a run reads only a handful of companies and then stops with a message.

#### How fresh is a record?

`sourceUpdatedAt` is the date the source last refreshed that company. Large and active companies are refreshed within days or weeks; dormant ones less often.

#### Can I look up an LLP or a director by DIN?

Not yet. Companies with a CIN only.

#### Is there an API?

Yes. Start a run with the [Apify API](https://docs.apify.com/api/v2) or the Python / Node.js clients and read the dataset; n8n, Make and Zapier work the same way. AI agents can call it through `https://mcp.apify.com/?tools=data_daemon/india-company-data`.

#### Is it legal to use this data?

Company master data and the names of directors are public records under the Companies Act. The Actor reads public pages without logging in and returns no personal contact details. Use the data in line with the laws that apply to you, including India's DPDP Act when you process information about individuals.

### Related Actors

- [India New Company Registrations](https://apify.com/data_daemon/india-new-company-registrations): companies incorporated on a given date, for daily lead feeds
- [NSE Corporate Announcements API](https://apify.com/data_daemon/nse-corporate-announcements) and [BSE Corporate Announcements API](https://apify.com/data_daemon/bse-corporate-announcements): filings of listed companies
- [India IPO Tracker API](https://apify.com/data_daemon/india-ipo-tracker): IPO calendar, subscription and grey-market premium
- [All Daemon Data Actors](https://apify.com/data_daemon)

### Support

Found a company that reads wrongly? Open an issue on the **Issues** tab with the CIN and the field that looks wrong.

# Actor input Schema

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

Corporate Identification Numbers to look up, for example `L17110MH1973PLC019786`. Pasted lines and URLs that contain a CIN work too. This is the exact way in: one CIN gives one company. Leave both lists empty to see three sample companies.

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

Registered company names to resolve to a CIN, for example `Tata Consultancy Services Limited`. The register is searched from the start of the name, so type the name as it is registered (the first words are enough). Each row says how it matched: `exact`, `name` (same name without Private / Limited) or `partial` (starts with your text; check it).

## `matchesPerName` (type: `integer`):

How many companies to return for each name (1 = the best match only). Use 3-6 when you search a group name such as `Zomato` and want its companies.

## `includeDirectors` (type: `boolean`):

Adds the current board (name, DIN, designation, appointment date, number of directorships, disqualification flags) and the signatories (company secretary, CFO and other signing officers). Public-record governance data only: no phone numbers, no personal email. One extra page per company at no extra charge.

## `includeRelatedCompanies` (type: `boolean`):

Adds `relatedCompanies`: other companies with at least one common director (name, status, state, number of common directors). Useful for due diligence; makes rows of large groups long.

## `onlyChanged` (type: `boolean`):

For scheduled runs over the same list. The first run returns every company; later runs return (and charge) only companies whose status, capital, address, email, filing dates, compliance flags or board changed, with `changeType` and `changedFields`. Unchanged companies cost nothing.

## `stateName` (type: `string`):

Name of the memory used by watchlist mode. Use a different name for each separate list.

## `maxItems` (type: `integer`):

Stop after this many companies (0 = the whole list).

## `proxyConfiguration` (type: `object`):

Keep Apify Proxy on: the source allows a limited number of page views per IP address, and the Actor spreads a list over many addresses. Without a proxy only about a dozen companies can be read per run.

## Actor input object example

```json
{
  "cins": [
    "L17110MH1973PLC019786",
    "L85110KA1981PLC013115",
    "L22210MH1995PLC084781"
  ],
  "companyNames": [],
  "matchesPerName": 1,
  "includeDirectors": true,
  "includeRelatedCompanies": false,
  "onlyChanged": false,
  "stateName": "default",
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

One JSON item per company in the default dataset (also downloadable as CSV, Excel, XML).

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

RUN-SUMMARY record: how many CINs and names were asked for, saved, unchanged (watchlist mode) and not found, with the reason for each query that returned nothing.

# 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 = {
    "cins": [
        "L17110MH1973PLC019786",
        "L85110KA1981PLC013115",
        "L22210MH1995PLC084781"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_daemon/india-company-data").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 = {
    "cins": [
        "L17110MH1973PLC019786",
        "L85110KA1981PLC013115",
        "L22210MH1995PLC084781",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_daemon/india-company-data").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 '{
  "cins": [
    "L17110MH1973PLC019786",
    "L85110KA1981PLC013115",
    "L22210MH1995PLC084781"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_daemon/india-company-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_daemon/india-company-data"
        }
    }
}
```

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/z0EYyFoqRpeqe0qMa/builds/cuQRA9N6E4KLsqIjI/openapi.json