# India MCA Company Data Scraper - CIN, Directors & Charges (`haketa/india-mca-scraper`) Actor

India company data scraper & API (MCA / CIN lookup): enrich any Indian company by CIN and export name, status, incorporation date, RoC, category, authorized & paid-up capital, address, email, directors with DIN & registered charges. India KYC, due-diligence & B2B lead data — fast, no login.

- **URL**: https://apify.com/haketa/india-mca-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 129 total users, 20 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 MCA Company Data Scraper 🇮🇳 — CIN Lookup, Directors (DIN), Capital & Registered Charges

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify)](https://apify.com/haketa/india-mca-scraper)
[![Data Freshness](https://img.shields.io/badge/Data-Live%20Corporate%20Registry-success)]()
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20Companies-orange)]()
[![No Login](https://img.shields.io/badge/Auth-No%20Login%20or%20Captcha-brightgreen)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-purple)]()

**Enrich any registered Indian company by its Corporate Identification Number (CIN) or discover 1,000+ Indian corporate profiles in minutes.** This **India MCA company scraper** and **CIN lookup API** transforms a list of CINs (or seed companies) into structured, analysis-ready corporate records: **company name, legal status, date of incorporation, Registrar of Companies (RoC), company class & category, listing status, authorized & paid-up capital, registered office address, official email, the full board of directors (with DIN & appointment dates), and registered secured charges.**

Export your results in bulk to **JSON, CSV, Excel (XLSX), XML, or via the Apify API** for **India KYB/KYC onboarding, commercial credit & risk underwriting, B2B lead enrichment, M\&A due diligence, and vendor compliance**.

> 💡 **Built for:** KYB and compliance teams, B2B lenders and fintech underwriting platforms, Indian B2B sales and lead-generation teams, M\&A and legal due-diligence analysts, credit bureaus, and data engineers maintaining Indian corporate intelligence pipelines.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target registry data** | Indian registered companies (Public, Private, OPC, Government, Listed & Unlisted) keyed by 21-character **CIN** |
| **Lookup & discovery modes** | Exact bulk **CIN list enrichment** (`cins`), automatic **CIN extraction from URLs** (`companyUrls`), or **corporate-graph expansion** up to `maxItems: 1000+` |
| **Core firmographics** | `cin`, `companyName`, `status`, `classOfCompany`, `category`, `subcategory`, `listingStatus`, `dateOfIncorporation`, `dateOfLastAGM`, `dateOfBalanceSheet`, `registrationNumber`, `rocCode`, `numberOfMembers` |
| **Financial & capital fields** | `authorizedCapital`, `paidUpCapital` (in INR), `chargesCount`, `openChargesCount` |
| **Contact & location fields** | `email` (registered official corporate email), `registeredAddress`, `otherAddress`, `pincode`, `description` |
| **Board of directors (`directors[]`)** | Full signatory & director list: `name`, `din` (Director Identification Number), `beginDate`, `status`, `updatedOn`, plus `directorsCount` |
| **Secured liabilities (`charges[]`)** | Registered charges against company assets: `amount`, `assets`, `dateOfCreation`, `dateOfModification`, `status` (`OPEN` / `CLOSED`) |
| **Scale & speed** | Pure HTTP parallel architecture (`maxConcurrency` up to `15`) — enriches **500 companies in ~90 seconds** and scales to **1,000+ companies** (`0` duplicates) |
| **Authentication** | None required — no MCA portal captchas, no login, no API keys |
| **Export & integrations** | JSON, CSV, Excel, XML, RSS, Apify API, Google Sheets, Make, Zapier, n8n, Snowflake, BigQuery & webhooks |

***

### 📋 Table of contents

- [Why scrape India MCA company data?](#-why-scrape-india-mca-company-data)
- [What this India MCA scraper does](#-what-this-india-mca-scraper-does)
- [Understanding the 21-character Indian CIN](#-understanding-the-21-character-indian-cin)
- [High-value use cases](#-high-value-use-cases)
- [Input configuration](#-input-configuration)
- [Output dataset & examples](#-output-dataset--examples)
- [Field reference & coverage](#-field-reference--coverage)
- [Bulk enrichment & 1,000+ corporate-graph scaling](#-bulk-enrichment--1000-corporate-graph-scaling)
- [How to use step by step](#️-how-to-use-step-by-step)
- [API & automation integration](#-api--automation-integration)
- [Pro tips for best results](#-pro-tips-for-best-results)
- [Frequently asked questions](#-frequently-asked-questions)
- [Limitations](#-limitations)
- [Related scrapers](#-related-scrapers)
- [Changelog](#-changelog)

***

### 🔎 Why scrape India MCA company data?

Every company incorporated in India under the Ministry of Corporate Affairs (MCA) is assigned a unique 21-character **Corporate Identification Number (CIN)** — such as `L17110MH1973PLC019786` (Reliance Industries) or `L22210MH1995PLC084781` (Tata Consultancy Services). Tied to that CIN is the company's statutory corporate record: its legal standing (`Active`, `Strike Off`, `Under Liquidation`), share capital structure, registered office address, statutory filing dates (last AGM and balance sheet), board of directors (each identified by a unique **DIN**), and secured bank loans (**registered charges**).

Looking up companies manually one by one across registry pages, solving captchas, and copying director tables and charge ledgers by hand is impossible when you have hundreds or thousands of vendors, borrowers, or B2B prospects. This **India MCA company scraper** automates the entire workflow: pass a list of CINs (or let the scraper expand from seed companies) and receive a clean, normalized JSON/CSV/Excel dataset in seconds.

**Common reasons teams scrape Indian corporate registry data:**

- 🛡️ **Automated KYB & vendor onboarding** — instantly verify whether an Indian counterparty is `Active` or `Strike Off`, confirm its incorporation date, and validate its registered office address.
- 🏦 **Commercial lending & credit-risk underwriting** — inspect `authorizedCapital`, `paidUpCapital`, `openChargesCount`, and individual secured `charges[]` to evaluate leverage and existing asset pledges before extending credit.
- 🧲 **B2B sales & account enrichment** — enrich raw CIN lists (from GST invoices, tender awards, or trade directories) with the company's **official registered `email`**, **director names (`directors[]`)**, and **paid-up capital** to prioritize high-value accounts.
- 🕵️ **M\&A, legal & investigative due diligence** — map board memberships via **DIN (`din`)**, audit AGM and balance-sheet filing compliance (`dateOfLastAGM`, `dateOfBalanceSheet`), and review historical asset charges.
- 📊 **Sector & regional market mapping** — build 1,000+ company datasets across Maharashtra, Karnataka, Delhi, Gujarat, Tamil Nadu, and Telangana for market sizing.

***

### ✨ What this India MCA scraper does

- ✅ **Bulk CIN lookup & enrichment** — pass 1, 100, or 1,000+ CINs and get a complete structured company profile for each.
- ✅ **Automatic corporate-graph expansion for 1,000+ runs** — when you leave `cins` empty or set `maxItems` higher than the number of seed CINs provided (e.g. `maxItems: 1000`), the scraper automatically discovers related subsidiaries, industry peers, and group companies to fulfill your full target count.
- ✅ **URL-aware input parsing** — paste any company profile URL containing a CIN into `companyUrls` (or `cins`) and the 21-character CIN is extracted and normalized automatically.
- ✅ **Complete statutory firmographics** — extracts `companyName`, `status`, `classOfCompany`, `category`, `subcategory`, `listingStatus`, `dateOfIncorporation`, `dateOfLastAGM`, `dateOfBalanceSheet`, `registrationNumber`, `rocCode`, `numberOfMembers`, `authorizedCapital`, `paidUpCapital`, `email`, `registeredAddress`, `otherAddress`, `pincode`, and `description`.
- ✅ **Board of directors with DIN (`directors[]`)** — returns every listed director/promoter with `name`, `din`, `beginDate`, `status`, and `updatedOn`, plus `directorsCount`.
- ✅ **Registered secured charges (`charges[]`)** — captures `amount`, `assets`, `dateOfCreation`, `dateOfModification`, and `status`, alongside summary counters `chargesCount` and `openChargesCount`.
- ✅ **Dual-tier high-coverage architecture** — combines a deep primary corporate data layer with an automatic secondary fallback layer (`dataSource: "primary"` vs `"secondary"`) to achieve **~100% lookup resolution** across valid Indian CINs.

***

### 🧩 Understanding the 21-character Indian CIN

Every Indian CIN follows a strict 6-part structure (`L17110MH1973PLC019786`) that you can also use to filter and segment your exported dataset:

| Position | Example | Meaning |
|---|---|---|
| **1st character** | `L` or `U` | **Listing status:** `L` = Listed on a recognized Indian stock exchange; `U` = Unlisted |
| **Digits 2–6** | `17110` | **NIC industry code:** 5-digit National Industrial Classification activity code |
| **Letters 7–8** | `MH`, `KA`, `DL`, `GJ` | **State code:** Two-letter Indian state/UT of registration (`MH` = Maharashtra, `KA` = Karnataka, `DL` = Delhi) |
| **Digits 9–12** | `1973` | **Year of incorporation:** Four-digit founding year |
| **Letters 13–15** | `PLC`, `PTC`, `OPC`, `GOI` | **Ownership class:** `PLC` = Public Limited, `PTC` = Private Limited, `OPC` = One Person Company, `GOI` = Government of India |
| **Digits 16–21** | `019786` | **Registration number:** 6-digit sequential number assigned by the state Registrar of Companies (RoC) |

***

### 🎯 High-value use cases

#### 1. Fintech & B2B credit underwriting

Before approving working-capital loans, invoice discounting, or trade credit to an Indian enterprise, underwriting pipelines query this Actor by CIN to check three critical signals:

1. Is `status === "Active"` and is `dateOfBalanceSheet` recent?
2. Does `paidUpCapital` support the requested credit line?
3. How many `openChargesCount` exist in `charges[]`, and what `amount` and `assets` are already pledged to other lenders?

#### 2. B2B lead enrichment (pairing with IndiaMART & GST data)

Raw supplier lists often lack decision-maker names, company size indicators, or official emails. Enriching Indian companies via this scraper appends the **board of directors (`directors[].name`)**, the **statutory corporate `email`**, and **paid-up capital** (an objective proxy for company scale).

#### 3. Continuous KYB & vendor portfolio monitoring

Schedule monthly runs across your active vendor CIN list to detect companies whose `status` shifts from `Active` to `Strike Off` or `Under Liquidation`, or companies that register sudden large new secured `charges`.

***

### 📥 Input configuration

All fields are optional. Paste your own list of CINs, or run with default settings to automatically enrich a sample (or scale to 1,000+ companies by raising `maxItems`).

| Field | Type | Default / Prefill | Description |
|---|---|---|---|
| `cins` | `array<string>` | Prefill: 2 seed CINs | Corporate Identification Numbers (21 characters, e.g. `L17110MH1973PLC019786`), one per entry. Leave empty or combine with a higher `maxItems` to auto-discover related Indian companies. |
| `companyUrls` | `array<string>` | `[]` | Optional: paste any company URLs that contain a 21-character CIN; the scraper extracts the CIN automatically. |
| `includeCharges` | `boolean` | `true` | Include each company's `charges[]` array (secured loans and asset pledges). Set to `false` for lighter records. |
| `maxItems` | `integer` | Default `0` (Prefill `50`) | Maximum companies to return (`0` = enrich all provided `cins`; set to `100`, `500`, or `1000+` to automatically expand and enrich related Indian companies). |
| `maxConcurrency` | `integer` | `5` (`1`–`15`) | Number of parallel company lookups. Raise to `10`–`15` for high-speed bulk runs. |
| `proxyConfiguration` | `object` | `{ "useApifyProxy": true }` | Proxy configuration. Default Apify Proxy works out of the box. |

#### Input example 1 — Enrich a specific list of CINs (`maxItems: 0`)

```json
{
  "cins": [
    "L17110MH1973PLC019786",
    "L22210MH1995PLC084781",
    "L85110KA1981PLC013115",
    "L65920MH1994PLC080618"
  ],
  "includeCharges": true,
  "maxItems": 0
}
```

#### Input example 2 — Discover & enrich 1,000+ Indian companies automatically

```json
{
  "cins": [
    "L17110MH1973PLC019786",
    "L22210MH1995PLC084781"
  ],
  "includeCharges": true,
  "maxItems": 1000,
  "maxConcurrency": 10
}
```

***

### 📤 Output dataset & examples

Each company is saved as a single structured JSON record containing its statutory firmographics, `directors[]`, and `charges[]`.

#### Sample output record

```json
{
  "cin": "U00000PB2003PTC026066",
  "dataSource": "primary",
  "companyName": "A.N.E. INDUSTRIES PRIVATE LIMITED",
  "status": "Active",
  "classOfCompany": "Private",
  "category": "Company limited by Shares",
  "subcategory": "Non-govt company",
  "listingStatus": "Unlisted",
  "dateOfIncorporation": "29-05-2003",
  "dateOfLastAGM": "30-09-2022",
  "dateOfBalanceSheet": "31-03-2022",
  "registrationNumber": "026066",
  "rocCode": "RoC-Chandigarh",
  "numberOfMembers": "0",
  "authorizedCapital": "2,00,00,000",
  "paidUpCapital": "1,94,91,000",
  "email": "rajinder@aneindustries.com",
  "registeredAddress": "CHANDIGARH ROAD NAWANSHAHR Nawan Shehar PB 144514 IN",
  "otherAddress": null,
  "pincode": "144514",
  "description": "A.N.E. INDUSTRIES PRIVATE LIMITED is a Private registered under RoC-Chandigarh...",
  "directors": [
    {
      "name": "GAGANDEEP SINGH",
      "din": "01655358",
      "beginDate": "2003-05-29",
      "status": "Approved",
      "updatedOn": "2019-06-26"
    }
  ],
  "directorsCount": 2,
  "chargesCount": 103,
  "openChargesCount": 53,
  "charges": [
    {
      "amount": "64390000",
      "assets": "Movable property (not being pledge)",
      "dateOfCreation": "19/06/2013",
      "dateOfModification": null,
      "status": "OPEN"
    }
  ],
  "url": "https://www.indiafilings.com/search/company-cin-U00000PB2003PTC026066",
  "scrapedAt": "2026-11-10T02:00:00.000Z"
}
```

***

### 📊 Field reference & coverage

#### 🏛️ Statutory Identity & Classification

| Field | Type | Coverage | Description |
|---|---|---|---|
| `cin` | `string` | 🟢 High (100%) | 21-character Corporate Identification Number (unique primary key). |
| `companyName` | `string` | 🟢 High (100%) | Official registered legal name of the company. |
| `status` | `string \| null` | 🟢 High (~99%) | Current registry status (`Active`, `Strike Off`, `Amalgamated`, `Under Liquidation`, etc.). |
| `classOfCompany` | `string \| null` | 🟢 High (~99%) | `Public`, `Private`, or `One Person Company`. |
| `category` | `string \| null` | 🟢 High (Primary) | Company category (e.g. `Company limited by Shares`, `Company limited by Guarantee`). |
| `subcategory` | `string \| null` | 🟢 High (Primary) | Subcategory (e.g. `Non-govt company`, `Union Govt company`, `Subsidiary of Foreign Company`). |
| `listingStatus` | `string \| null` | 🟢 High (100%) | `Listed` or `Unlisted`. |
| `registrationNumber` | `string \| null` | 🟢 High (100%) | 6-digit RoC registration number. |
| `rocCode` | `string \| null` | 🟢 High (Primary) | Registrar of Companies jurisdiction (e.g. `RoC-Mumbai`, `RoC-Bangalore`, `RoC-Delhi`). |
| `dataSource` | `string` | 🟢 High (100%) | `"primary"` (full director/charge profile) or `"secondary"` (core statutory fallback). |

#### 💰 Capital, Filings & Contact Details

| Field | Type | Coverage | Description |
|---|---|---|---|
| `authorizedCapital` | `string \| null` | 🟢 High (100%) | Authorized share capital in INR. |
| `paidUpCapital` | `string \| null` | 🟢 High (100%) | Paid-up share capital in INR. |
| `dateOfIncorporation` | `string \| null` | 🟢 High (100%) | Incorporation date (`DD-MM-YYYY` or `DD Month, YYYY`). |
| `dateOfLastAGM` | `string \| null` | 🟢 High (Primary) | Date of most recent Annual General Meeting filing. |
| `dateOfBalanceSheet` | `string \| null` | 🟢 High (Primary) | Date of latest filed balance sheet. |
| `numberOfMembers` | `string \| null` | 🟡 Conditional | Number of members when reported. |
| `email` | `string \| null` | 🟢 High (~89% Primary) | Statutory corporate email address on file. |
| `registeredAddress` | `string \| null` | 🟢 High (100%) | Complete registered office street address, city, state, and PIN. |
| `otherAddress` | `string \| null` | 🟡 Conditional | Secondary/correspondence address when filed. |
| `pincode` | `string \| null` | 🟢 High (~85%) | 6-digit Indian PIN code. |
| `description` | `string \| null` | 🟢 High (Primary) | Narrative summary of the company's registration details. |

#### 👥 Board of Directors & Secured Charges

| Field | Type | Coverage | Description |
|---|---|---|---|
| `directors` | `array<object>` | 🟢 High (~88% Primary) | Array of `{ name, din, beginDate, status, updatedOn }` objects. |
| `directorsCount` | `integer \| null` | 🟢 High (Primary) | Total directors/signatories listed on the board. |
| `charges` | `array<object>` | 🟡 Conditional (`includeCharges`) | Array of `{ amount, assets, dateOfCreation, dateOfModification, status }` secured loan records. |
| `chargesCount` | `integer \| null` | 🟢 High (Primary) | Total historical and active charges registered. |
| `openChargesCount` | `integer \| null` | 🟢 High (Primary) | Count of currently active (`OPEN`) secured charges. |
| `url` | `string` | 🟢 High (100%) | Reference profile URL. |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO-8601 extraction timestamp. |

***

### 🔁 Bulk enrichment & 1,000+ corporate-graph scaling

This Actor supports two seamless operating modes depending on your workflow:

1. **Exact CIN list enrichment (`maxItems: 0`):** Paste 10, 200, or 5,000 CINs into `cins` (or `companyUrls`) and leave `maxItems` at `0`. The scraper deduplicates your input list and enriches **only** the exact CINs you provided using a bounded parallel worker pool (`maxConcurrency`).
2. **Corporate-graph discovery & expansion (`maxItems > cins.length`):** When you run with an empty `cins` list or provide a handful of seed CINs alongside a higher `maxItems` target (such as `50`, `250`, or `1,000+`), the scraper automatically harvests related subsidiary, group, and industry-peer CINs from the corporate registry graph and enriches them in parallel until your exact `maxItems` target is reached with **0 duplicate CINs**.

***

### ⚙️ How to use step by step

1. Open **[India MCA Company Data Scraper](https://apify.com/haketa/india-mca-scraper)** in the Apify Console and click **Try for free**.
2. Paste your list of 21-character **Company CINs to look up** (`cins`), or keep the default seed CINs to test automatic discovery.
3. Choose whether to **Include registered charges** (`includeCharges: true`).
4. Set **Maximum companies to return** (`maxItems`) — use `0` to process only your exact `cins` list, or set `50`, `200`, or `1000` to automatically expand and collect that many companies.
5. Click **Start** and download your enriched dataset as **JSON, CSV, Excel, XML, or HTML**.

***

### 🔌 API & automation integration

#### Python example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("haketa/india-mca-scraper").call(run_input={
    "cins": [
        "L17110MH1973PLC019786",
        "L22210MH1995PLC084781",
        "L85110KA1981PLC013115",
    ],
    "includeCharges": True,
    "maxItems": 0,
    "maxConcurrency": 10,
})

for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["cin"], company["companyName"], company["status"], company["paidUpCapital"], company["email"])
```

#### Node.js example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('haketa/india-mca-scraper').call({
    cins: ['L17110MH1973PLC019786'],
    maxItems: 250,
    includeCharges: true,
    maxConcurrency: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Enriched ${items.length} Indian companies.`);
```

***

### 💡 Pro tips for best results

- 🚀 **Increase `maxConcurrency` to `10`–`15` for large runs:** Because the scraper uses lightweight pure-HTTP requests with per-request proxy rotation, 1,000 companies finish in roughly 2.5–3 minutes at concurrency 10.
- 🪶 **Turn off `includeCharges` when you only need contact/board data:** Large industrial enterprises can have 100+ historical bank charges; setting `includeCharges: false` keeps CSV/JSON payloads compact while still preserving `chargesCount` and `openChargesCount`.
- 🔍 **Filter by `dataSource: "primary"` for full board & email enrichment:** Records resolved via the primary layer carry the full `directors[]`, `charges[]`, and `email` fields; `secondary` fallback records provide guaranteed core statutory coverage (`companyName`, `dateOfIncorporation`, `authorizedCapital`, `paidUpCapital`, `registeredAddress`, `status`).

***

### ❓ Frequently asked questions

**What is a CIN and where do I find it?**
A **Corporate Identification Number (CIN)** is the official 21-character alphanumeric identifier assigned by the Ministry of Corporate Affairs (MCA) to every company registered in India (e.g. `L17110MH1973PLC019786`). It appears on company invoices, letterheads, annual reports, and financial filings.

**Can this scraper discover 1,000+ Indian companies if I only have a few seed CINs?**
Yes. Whenever `maxItems` is set higher than the number of CINs in your input (or when `cins` is left empty), the scraper automatically traverses the corporate registry graph from your seed CINs to discover and enrich up to `maxItems` unique companies (`1,000+` supported).

**What happens if I only want to enrich my exact list of CINs without adding related companies?**
Simply set `maxItems: 0` (the default). When `maxItems` is `0` and you provide one or more `cins` or `companyUrls`, the scraper enriches **only** the exact CINs you supplied.

**Do I need an MCA login or captcha solver?**
No. Everything runs over fast, headless HTTP with zero login and zero captcha prompts.

***

### ⚠️ Limitations

- Lookup and discovery are keyed by 21-character Indian company **CINs** (`[LU]\d{5}[A-Z]{2}\d{4}[A-Z]{3}\d{6}`); Limited Liability Partnerships (LLPs, which use a 7-character LLPIN) are not covered by the CIN format.
- Records resolved via the `secondary` fallback source include core statutory fields (`companyName`, `status`, `classOfCompany`, `listingStatus`, `dateOfIncorporation`, `authorizedCapital`, `paidUpCapital`, `registeredAddress`, `pincode`) but omit `directors[]`, `charges[]`, and `email`.

***

### 🔗 Related scrapers

Pair Indian corporate registry intelligence with these B2B and company data scrapers:

- [IndiaMART Scraper — Suppliers, Exporters, Prices & GST](https://apify.com/haketa/indiamart-scraper) — discover Indian B2B manufacturers, GST numbers, IEC codes, and export markets.
- [TradeIndia Scraper](https://apify.com/haketa/tradeindia-scraper) — extract Indian wholesale suppliers and product catalogs.
- [Dun & Bradstreet Scraper — Companies, DUNS & Revenue](https://apify.com/haketa/dnb-scraper) — global firmographics, DUNS numbers, revenue, and principals.
- [BBB Scraper — Better Business Bureau Profiles](https://apify.com/haketa/bbb-scraper) — North American company ratings, accreditation, and complaint histories.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ corporate-graph discovery & scaling:** Added automatic related-CIN harvesting (`harvestCinsFromHtml`) when `cins` is empty or when `maxItems` exceeds the seed CIN count, allowing single runs to scale to 1,000+ unique Indian companies while preserving exact-list mode when `maxItems: 0`.
- **Enhanced secondary fallback fields:** Derived `classOfCompany`, `listingStatus`, `registrationNumber`, and 6-digit `pincode` automatically on secondary-source records.
- **Fast prefill tuning:** Set `maxItems` prefill to `50` for rapid `< 25s` verification runs with 0 duplicates.
- **Documentation upgrade:** Expanded README with `At a glance` table, 21-character CIN structure breakdown, emoji field tables, and API examples.

#### v1.1 (2026-11)

- Verified 500-company benchmark run in 89 seconds with 100% core statutory field coverage and 0 duplicate CINs.

#### v1.0 (2026-06)

- Initial release with dual-source CIN enrichment, RSC payload extraction for directors (DIN) and secured charges, and URL-embedded CIN detection.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/india-mca-scraper/changelog.md

# Actor input Schema

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

Paste the Corporate Identification Numbers (CIN) of the Indian companies you want to enrich, one per row (e.g. L17110MH1973PLC019786). Leave this empty to get a ready-made sample of well-known Indian companies so you can preview the data instantly.

## `companyUrls` (type: `array`):

Optional. Already have company profile links that contain a CIN? Paste them here and the CIN is detected automatically. Most users only need the CINs field above.

## `includeCharges` (type: `boolean`):

Also include each company's registered charges (secured loans and liabilities) in the results — useful for credit and due-diligence checks.

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

Cap how many companies to save so you can control run time and cost. Set 0 for no limit (scrapes all provided CINs), or set a higher number (e.g. 100 or 1,000+) to automatically discover and enrich related Indian companies.

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

How many companies to look up at the same time. Higher is faster; lower is gentler.

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

Proxy settings. Keeping the Apify proxy on is recommended for reliable, larger runs.

## Actor input object example

```json
{
  "cins": [
    "L17110MH1973PLC019786",
    "L65920MH1994PLC080618"
  ],
  "includeCharges": true,
  "maxItems": 50,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Open to view, filter and export all enriched company profiles from this run (JSON, CSV, Excel).

# 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",
        "L22210MH1995PLC084781"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/india-mca-scraper").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",
        "L22210MH1995PLC084781",
    ],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/india-mca-scraper").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",
    "L22210MH1995PLC084781"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/india-mca-scraper --silent --output-dataset

```

## MCP server setup

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

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/fzKVXNkrFRbIs8m1j/builds/JYizIja1CYSIZIufl/openapi.json