# India NSE Filings — Announcements, Results & Corporate Actions (`foxlabs/india-listed-company-filings`) Actor

NSE India listed-company filings from official public JSON endpoints: corporate announcements with PDF links, quarterly financial results with XBRL key figures (revenue, profit, EPS), dividend/split/bonus corporate actions and the 2,500+ company equity list. Filter by symbol, date and keyword.

- **URL**: https://apify.com/foxlabs/india-listed-company-filings.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Business, News
- **Stats:** 3 total users, 0 monthly users, 89.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 filing records

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 NSE Filings — Announcements, Results & Corporate Actions 🇮🇳

**foXLabs India series:** [Company registry](https://apify.com/foxlabs/indian-company-data) · [Government tenders](https://apify.com/foxlabs/india-government-tenders) · [Tech hiring signals](https://apify.com/foxlabs/india-tech-hiring-signals) · [IndiaMART suppliers](https://apify.com/foxlabs/indiamart-supplier-data)

🎉 Turn the National Stock Exchange of India's public filing feeds into clean, structured rows — no login, no API key: corporate announcements with the filed PDF, quarterly results with official XBRL figures (revenue, profit, EPS), dividends, splits and bonus issues, and NSE's list of 2,568 listed companies with ISINs.
Built for KYC / due-diligence analysts, equity research, compliance monitoring and B2B intelligence on Indian listed companies.

### 🔍 What is India NSE Filings — and when should you use it?

Pick a feed, optionally name companies by their NSE symbol, choose a date range, and this actor returns the matching filings from NSE's own public JSON endpoints and archive files — as clean, flat rows you can filter, export or feed to an AI agent. Every run reads NSE live, on the default automatic Apify Proxy: no residential proxy, cookies or API key needed.

**Use it when you need:** what an Indian listed company has just disclosed (board outcomes, auditor changes, resignations, credit ratings, press releases); a company's quarterly revenue, profit and EPS straight from its XBRL filing; a dividend, split and bonus calendar; or NSE symbol ↔ ISIN master data.

**Use something else when:** you need BSE-only companies (BSE is not covered), live prices or trades (not included — NSE licenses market data separately), or unlisted companies — for those, use [Indian Company Data](https://apify.com/foxlabs/indian-company-data) (MCA registry: CIN, directors, financials).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/india-listed-company-filings`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: one `filing-record` event per delivered data row.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want to pull NSE India company filings using the Apify Actor `foxlabs/india-listed-company-filings`.
Input: `mode` is announcements, financial_results, corporate_actions or equity_list. `symbols` is an optional list of NSE trading symbols (INFY, TCS, HDFCBANK). `datePreset` is last_24_hours, last_7_days, last_30_days or custom (then `dateFrom` / `dateTo` as YYYY-MM-DD). `keyword` filters subject and description. `includeXbrl` adds revenue, profit and EPS to financial results. `maxResults` caps rows (0 = no limit).
Start with: {"mode":"announcements","datePreset":"last_7_days","maxResults":20}
Ask me which companies or events I care about, run the Actor, then summarise the rows as a table.
```

Things you can ask your agent for:

- "Show Infosys, TCS and HDFC Bank revenue and net profit for every quarter since January 2025."
- "List every dividend with an ex-date in the last 30 days, with the amount per share."
- "Which NSE companies disclosed a change in auditors this week? Link the filings."

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/india-listed-company-filings.md`.

### 📋 Overview

Everything you need to turn NSE India's public disclosures into clean, structured data — in one actor, with no login, cookies or API key.

**Why teams pick this actor:**

- ✅ **Four NSE feeds, one actor** — announcements, quarterly results, corporate actions and the equity list.
- 📊 **Filings as numbers** — revenue, total income, expenses, profit before and after tax, EPS and paid-up capital read from each result's official XBRL document; total assets and equity on March and September filings.
- 🔗 **Current identifiers** — the NSE symbol plus the current ISIN from NSE's official equity list (NSE's filing feeds still carry a pre-split ISIN for about one company in five; this actor replaces it), and `isinSource` on every row says where the ISIN came from.
- 🧾 **Evidence attached** — announcements link the filed document on NSE's archive (text-only disclosures have none), results their XBRL file (and, for integrated filings, the inline-XBRL page).
- 🚦 **No silent failures** — an unknown symbol returns an error row with a "Did you mean …" hint; an empty, blocked, degraded or invalid run explains itself in a `source_report` row.
- 💰 **Pay only for data rows** — one `filing-record` event per row; error and summary rows don't fire it.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 📰 **Corporate announcements** — subject, full disclosure text, company, ISIN, IST timestamps, industry where NSE gives it, and the filed PDF with its size — market-wide or for chosen symbols.
- 📊 **Quarterly results + XBRL figures** — standalone and consolidated, audited flag, original vs revised, filing time; with `includeXbrl` the key P\&L lines as four-field money sets (`revenue`, `revenueCurrency`, `revenueFormatted`, `revenueExact` …).
- 🏦 **Bank-aware parsing** — banks report interest earned instead of revenue from operations; `revenueTag` tells you which XBRL element fed `revenue`.
- 💸 **Corporate actions, parsed** — purpose (`dividend`, `interim_dividend`, `split`, `bonus`, `rights`, `buyback` …), ex-date, record date, cash per share (a regular plus a special dividend is added up) and bonus / rights ratios.
- 🏷️ **Equity master data** — all 2,568 companies on NSE's equity list (main board) with ISIN, series, listing date, face value, paid-up value and market lot.
- 🔎 **Filters** — symbols, date presets or a custom range, keyword, `maxResults`.
- 🧹 **Clean values** — ISO dates, timestamps with an explicit `+05:30` offset, `null` for anything NSE doesn't publish, HTML entities decoded.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~india-listed-company-filings/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"announcements","datePreset":"last_7_days","maxResults":20}'
```

### 🚀 Getting Started (3 steps)

1. **Pick a feed** — `announcements`, `financial_results`, `corporate_actions` or `equity_list`.
2. **Narrow it** — optional NSE symbols, a date preset or custom range, a keyword, `maxResults`.
3. **Run and export** — JSON, CSV or Excel from the dataset, or straight into your pipeline through the API.

### 📥 Input

```json
{"mode":"financial_results","symbols":["INFY","TCS","HDFCBANK"],"includeXbrl":true,"datePreset":"custom","dateFrom":"2025-01-01"}
```

| Field | Type | Description |
|---|---|---|
| `mode` | string | `announcements` (default), `financial_results`, `corporate_actions` or `equity_list`. |
| `symbols` | array | Optional NSE trading symbols (`INFY`, `TCS`, `RELIANCE`). Checked against NSE's equity list (if the list can't be loaded in a run, they are used as given and the `degraded` summary row says so); for results and corporate actions a symbol returns the company's full history unless you pick a custom range. |
| `datePreset` | string | `last_24_hours`, `last_7_days` (default), `last_30_days` or `custom`. Dates are Indian Standard Time: announcements filter on announcement time, corporate actions on ex-date, results on filing date. |
| `dateFrom` / `dateTo` | string | `YYYY-MM-DD`, used with `custom`. An empty `dateTo` means today; a future `dateTo` lists upcoming ex-dates. |
| `keyword` | string | Case-insensitive match on subject, description, company name or purpose (`dividend`, `resignation`, `buyback` …). |
| `includeXbrl` | boolean | Financial results only: parse each result's XBRL document into key figures (one extra download per result). |
| `maxResults` | integer | Stop after this many data rows (default 500; `0` = no limit). Rows come in NSE's order — announcements newest first. |
| `requestDelayMs` | integer | Pause between requests; minimum and default 700 ms. |
| `proxyConfiguration` | object | Automatic Apify Proxy by default — keep it (see the FAQ). |

### 📤 Output

One flat row per filing; `recordType` tells you which of the four shapes you are looking at (`announcement`, `financial_result`, `corporate_action`, `company`). Every row carries `symbol`, `companyName`, `isin`, `isinSource` (`equity_list` = the current ISIN from NSE's official list; `feed` = the filing feed's own value, checksum-checked but possibly pre-split; `null` when no ISIN is known), `nseUrl` (link to the company's NSE quote page, built only for symbols on the equity list), `sourceEndpoint` (the NSE URL the row came from) and `scrapedAt` (UTC).

**`announcements`**

| Field | Description |
|---|---|
| `announcementId` | NSE's sequence id — unique per announcement |
| `subject` | NSE category, e.g. *Credit Rating*, *Change in Auditors*, *Outcome of Board Meeting* |
| `description` | The disclosure text as broadcast |
| `industry` | NSE industry label — NSE fills it for roughly 4 announcements in 10 |
| `announcementAt` / `disseminatedAt` | ISO 8601 in IST (`+05:30`) |
| `attachmentUrl` / `attachmentType` / `attachmentSizeBytes` | The filed document on `nsearchives.nseindia.com` (PDF, sometimes ZIP); `null` for text-only disclosures |
| `hasXbrl` | NSE's flag for an XBRL version of the announcement |

**`financial_results`**

| Field | Description |
|---|---|
| `filingId` / `filingSource` | Financial results only: unique id (`integrated-…` / `legacy-…`) and its feed, `nse-integrated-filing` (quarters from March 2025) or `nse-financial-results` (older quarters) |
| `periodStart` / `periodEnd` / `quarterLabel` / `financialYear` | Reporting period; `financialYear` only on the older feed |
| `consolidated` / `auditedFlag` / `filingStatus` / `revisionRemark` | Consolidated vs standalone, audited or not, `original` or `revised`, the company's revision note |
| `filingFormat` / `filedAt` | *Integrated Filing (SEBI)*, *Ind-AS New*, *Non-Ind-AS* …; filing time (IST) |
| `xbrlUrl` / `ixbrlUrl` / `pdfUrl` | XBRL instance document; inline-XBRL page (integrated filings); results PDF when NSE links one |
| `xbrlStatus` / `xbrlTaxonomy` / `xbrlFactCount` / `xbrlPeriodStart` / `xbrlPeriodEnd` / `xbrlCurrency` | `not_requested`, `parsed`, `missing`, `fetch_failed`, `parse_failed` or `blocked`; taxonomy (`INTEGRATED_FILING_INDAS`, `INTEGRATED_FILING_BANKING`, `INDAS`, `BANKING` …); facts found; period and currency of the figures |
| `revenue`, `totalIncome`, `totalExpenses`, `profitBeforeTax`, `taxExpense`, `netProfit`, `paidUpEquityCapital`, `totalAssets`, `totalEquity` | Each as a set of four: the INR number, `…Currency`, `…Formatted` (`₹482.11B`) and `…Exact` (`₹482,110,000,000`) |
| `revenueTag` / `epsBasic` / `epsDiluted` | The XBRL element behind `revenue`; earnings per share in INR |

**`corporate_actions`**

| Field | Description |
|---|---|
| `series` | `EQ` for shares; `IV` / `RR` for InvIT / REIT units; `GS` for government securities |
| `purpose` | `dividend`, `interim_dividend`, `special_dividend`, `split`, `bonus`, `rights`, `buyback`, `demerger`, `scheme_of_arrangement`, `merger`, `interest_payment`, `distribution`, `redemption`, `consolidation`, `agm`, `egm` or `other` |
| `subject` | NSE's wording, e.g. *Dividend - Rs 1.50 Per Share*, *Bonus 2:1* |
| `exDate` / `recordDate` | ISO dates |
| `amountPerShare` | INR per share or unit for dividends, distributions and interest (a regular plus a special dividend is added up) |
| `ratio` | `2:1`, `3:19` … when the subject states one (bonus, rights, schemes); splits show the old → new face value in `subject` |
| `faceValue` | Face value of the share |

**`equity_list`** — `series` (`EQ`, `BE`, `BZ`), `listingDate`, `faceValue`, `paidUpValue` and `marketLot`, straight from NSE's `EQUITY_L.csv`.

**Error and summary rows** — an unknown symbol gives `{"recordType": "error", "symbol": …, "error": …}` and no request is spent on it; a run that ends empty, blocked, degraded or with invalid input writes one `{"recordType": "source_report", "status": …, "message": …}` row, where `status` is `empty`, `empty_suspicious`, `blocked`, `invalid_symbols`, `invalid_input` or `degraded`. `degraded` means NSE's equity list could not be loaded after three attempts: the rows still arrive, but their ISINs come from the filing feeds (`isinSource: "feed"`), `nseUrl` is empty and symbols were not validated. A `blocked` run still delivers the rows collected before the refusal.

Real rows from test runs on 10 September 2026 (the result row is abridged — the other money sets have the same four fields; it was captured before the `isinSource` field existed, which is `equity_list` for Infosys):

```json
{
  "recordType": "announcement",
  "announcementId": "106778079",
  "symbol": "PSB",
  "companyName": "Punjab & Sind Bank",
  "isin": "INE608A01012",
  "isinSource": "equity_list",
  "industry": "Banks",
  "subject": "Credit Rating",
  "description": "Punjab & Sind Bank has informed the Exchange about Credit Rating",
  "announcementAt": "2026-09-10T19:28:29+05:30",
  "disseminatedAt": "2026-09-10T19:28:30+05:30",
  "attachmentUrl": "https://nsearchives.nseindia.com/corporate/PSB_10092026192755_bsense10092026rating.pdf",
  "attachmentType": "pdf",
  "attachmentSizeBytes": 697303,
  "hasXbrl": true,
  "nseUrl": "https://www.nseindia.com/get-quotes/equity?symbol=PSB"
}
```

```json
{
  "recordType": "financial_result",
  "filingId": "integrated-177385",
  "filingSource": "nse-integrated-filing",
  "symbol": "INFY",
  "companyName": "Infosys Limited",
  "isin": "INE009A01021",
  "periodStart": "2026-04-01",
  "periodEnd": "2026-06-30",
  "quarterLabel": "First quarter",
  "consolidated": true,
  "auditedFlag": true,
  "filingStatus": "original",
  "filedAt": "2026-07-23T17:44:46+05:30",
  "xbrlUrl": "https://nsearchives.nseindia.com/corporate/xbrl/INTEGRATED_FILING_INDAS_1700136_23072026054446_WEB.xml",
  "xbrlStatus": "parsed",
  "xbrlTaxonomy": "INTEGRATED_FILING_INDAS",
  "revenueTag": "RevenueFromOperations",
  "revenue": 482110000000,
  "revenueCurrency": "INR",
  "revenueFormatted": "₹482.11B",
  "revenueExact": "₹482,110,000,000",
  "profitBeforeTax": 110280000000,
  "netProfit": 77750000000,
  "netProfitFormatted": "₹77.75B",
  "epsBasic": 19.19,
  "epsDiluted": 19.17,
  "totalAssets": null,
  "totalEquity": null
}
```

```json
{
  "recordType": "corporate_action",
  "symbol": "DVL",
  "companyName": "Dhunseri Ventures Limited",
  "isin": "INE477B01010",
  "isinSource": "equity_list",
  "series": "EQ",
  "purpose": "dividend",
  "subject": "Dividend - Rs 1.50 Per Share",
  "exDate": "2026-08-11",
  "recordDate": "2026-08-11",
  "amountPerShare": 1.5,
  "ratio": null,
  "faceValue": 10
}
```

*(₹482.11B = ₹48,211 crore. `totalAssets` and `totalEquity` are `null` on this first-quarter filing because it carries no balance sheet; on Infosys's 31-March-2026 consolidated filing they are ₹1.56T and ₹932.97B.)*

**Fill rates** (test runs of 10 September 2026; a value NSE does not publish stays `null`, it is never estimated):

| Mode · fields | Filled | Measured on |
|---|---|---|
| Announcements · symbol, company, ISIN, subject, description, announcement time | 100% | 200 newest rows of the last 7 days + 577 "dividend" rows of the last 30 days |
| Announcements · attached document | 94.5% | 200 newest rows — text-only disclosures have none |
| Announcements · industry | 39% / 36% | same two samples — NSE fills it for some companies only |
| Results · revenue, total income, PBT, tax, net profit, EPS, paid-up capital | 100% | 42 filings of INFY, TCS and HDFC Bank since January 2025 — 42 of 42 XBRL files parsed |
| Results · total expenses | 67% | bank filings have no such element |
| Results · total assets / total equity | 100% / 67% of March and September filings | first- and third-quarter filings carry no balance sheet; bank filings have no equity element |
| Corporate actions · identity, purpose, subject, ex-date, record date, face value | 100% | 359 actions with an ex-date in the last 30 days |
| Corporate actions · amount per share | 338 of 340 cash actions | two *Interest Payment* rows state no amount |
| Equity list · all fields | 100% | 2,568 companies |
| All modes · ISIN verified against the equity list (`isinSource: "equity_list"`) | 199/200 announcements · 344/359 corporate actions · 6/6 results · 2,568/2,568 companies | the others are `feed`: one symbol that is not on the equity list and 15 InvIT / REIT / G-sec units |

**Volume and speed** (default settings, 10 September 2026):

| Input | Rows | NSE requests | Run time |
|---|---|---|---|
| Announcements, last 7 days, `maxResults` 20 (the prefilled input; 28 September 2026) | 20 (of 4,421 in the window) | 2 | 9 s |
| Announcements, last 7 days, `maxResults` 200 | 200 (of 4,640 in the window) | 2 | 31 s |
| Announcements, last 30 days, keyword `dividend`, no limit | 577 (of 19,929 in the window) | 2 | 17 s |
| Financial results + XBRL for INFY, TCS, HDFCBANK since 2025-01-01 | 42 | 49 | 74 s |
| Corporate actions, last 30 days | 359 | 2 | 11 s |
| Equity list, no limit | 2,568 | 1 | 5 s |

A market-wide announcements window is a single request however many rows it holds; ranges longer than 31 days are split into monthly windows. XBRL figures cost one archive download per result.

### 💼 Use cases

**1. KYC and counterparty due diligence** — check a listed counterparty's numbers and recent disclosures.
*Input:* its NSE symbol with `financial_results` + `includeXbrl`, then `announcements` over the last 30 days. *Output:* quarterly revenue, profit and EPS with the XBRL files, plus auditor changes, resignations and credit-rating updates with the filed PDFs. *Use:* a documented file on the company.

**2. Event monitoring** — catch disclosures the day they are filed.
*Input:* `announcements` with `last_24_hours` and a keyword such as `resignation` or `credit rating`, on a daily schedule. *Output:* the matching disclosures with their PDFs. *Use:* a Slack or email alert.

**3. Dividend and corporate-action calendar** — track payouts and share changes.
*Input:* `corporate_actions` with `last_30_days`, or a custom range that ends in the future. *Output:* ex-dates, record dates, amount per share, bonus and rights ratios. *Use:* income tracking and portfolio accounting.

**4. Fundamentals from the filings** — quarterly P\&L time series straight from the source.
*Input:* a list of symbols with `financial_results` + `includeXbrl`. *Output:* one row per filing with the figures as numbers. *Use:* screening, research and model features.

**5. Master data** — map symbols to ISINs and listing dates.
*Input:* `equity_list` with `maxResults` 0. *Output:* all 2,568 companies. *Use:* enrich or de-duplicate your own company lists.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/india-listed-company-filings').call({"mode":"financial_results","symbols":["INFY","TCS"],"includeXbrl":true,"datePreset":"custom","dateFrom":"2025-01-01"});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/india-listed-company-filings').call(run_input={"mode":"corporate_actions","datePreset":"last_30_days"})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the actor API with your input → handle the JSON dataset → push to a sheet, CRM or alerting channel.

### 📊 Pricing

Pay-per-event: **one `filing-record` event per delivered data row** (announcement, result, corporate action or company). The Actor fires this event only for data rows — error rows and the `source_report` summary row don't trigger it — and the XBRL download is included in the result row. [View current pricing.](https://apify.com/foxlabs/india-listed-company-filings)

### ❓ FAQ

**Do I need an NSE account, login or API key?** No. The actor reads NSE's public JSON endpoints and archive files — no login, cookies or key.

**Do I need a residential proxy?** No — keep the default automatic Apify Proxy. In a test on 10 September 2026 NSE accepted the automatic proxy pool 10 times out of 10 but residential IPs only 5 times out of 10 (NSE's edge network refuses some IP addresses). If a run reports "NSE blocked this IP", simply start it again: every run uses a new proxy session, and the actor already retries from a fresh session before giving up (up to three attempts for NSE's equity list).

**Which exchange is covered?** NSE only. BSE is not covered — its site refuses non-browser access — but many large Indian companies are listed on both.

**Why two rows per quarter for a company?** Companies file standalone and consolidated results separately; `consolidated` tells them apart.

**Why do older quarters come from a different feed?** NSE moved to SEBI's integrated filing with the quarter ended 31 March 2025. Later quarters come from `nse-integrated-filing`, earlier ones from `nse-financial-results`; both are merged per company.

**Market-wide financial results look short.** NSE's integrated-filing list answers a market-wide query with its latest 20 filings only (the actor says so in the log). Pass `symbols` to get each company's complete history.

**What units are the figures in?** Absolute INR as filed (₹482,110,000,000 = ₹48,211 crore). `revenue` is revenue from operations for companies and interest earned for banks (`revenueTag` says which). Total assets and equity appear on March and September filings, which carry a balance sheet; bank filings have no equity or total-expenses element, so those stay `null`.

**Why can the ISIN differ from the one in NSE's announcement feed?** After a share split NSE issues a new ISIN, but its filing feeds keep the old one for about one company in five (measured on 10 September 2026). The actor returns the current ISIN from NSE's official equity list and marks it `isinSource: "equity_list"`. If that list can't be loaded in a run (it is tried three times), the rows keep the feed's ISIN, marked `isinSource: "feed"`, and the run adds a `degraded` summary row.

**How many announcements should I expect?** 4,640 were filed in the 7 days to 10 September 2026 and 19,929 in the 30 days to that date. On full weekdays from 1 to 9 September 2026 NSE carried 583–877 announcements a day; Saturday 5 September had 553 and Sunday 6 September 96. A market-wide window is a single request however many rows it holds.

**Can I search by company name?** Use the NSE symbol. If you type a name, the error row suggests the symbol — `INFOSYS` gets "Did you mean INFY (Infosys Limited)?" — and `equity_list` with a `keyword` finds it too.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **0 rows** — widen the date range, drop the keyword or check the symbol; the `source_report` row states the reason.
- **Error row "Symbol … is not on NSE's official equity list"** — you passed a company name, a BSE code or an SME / debt-only symbol; use the NSE equity symbol (the row suggests one when it can).
- **`xbrlStatus` is `missing`, `fetch_failed` or `parse_failed`** — NSE lists the result without a usable XBRL file; the result row is still delivered.
- **"NSE blocked this IP"** — run again on the default proxy (see the FAQ); rows collected before the refusal are still in the dataset.
- **A `degraded` summary row** — NSE refused its equity list three times in that run: the rows are there, but their ISINs are the feeds' own (`isinSource: "feed"`, possibly pre-split) and symbols were not validated. Run again for verified ISINs.
- **The prefilled input returns only the 20 newest announcements** — announcements come newest first and the prefill stops at 20 rows; raise `maxResults` or set it to `0` for the whole window.

### ⚠️ Trademark

Independent tool built on disclosures published by the National Stock Exchange of India. Not affiliated with or endorsed by NSE, BSE, SEBI or any listed company. Company names and "NSE" belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads corporate disclosures that listed companies file publicly with NSE — from NSE's public, cookie-less JSON endpoints and its archive of the filed documents, at a polite rate (at least 700 ms between requests, no HTML pages, no cookie or fingerprint tricks). NSE's website terms restrict systematic automated data collection, so you are responsible for how you use the data and for your own compliance; market data (prices, trades, indices) is deliberately not included — NSE licenses it separately. Results can contain personal data (e.g. a director's name in a disclosure); personal data is protected by the GDPR, India's DPDP Act and similar laws, so only process it with a legitimate basis. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab
- 🧰 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.6 — 2026-10-08 — README: the Python example works with the current Apify client

- The README's Python example read the results with `run['defaultDatasetId']`. With the current Apify client for Python (version 3) `call()` returns a run object, not a dict, and that line raised `TypeError: 'Run' object is not subscriptable` — after the run itself had finished. The example now reads `run.default_dataset_id`; with client version 1 or 2, keep `run['defaultDatasetId']`. Checked with apify-client 3.2.1, 2.5.1 and 1.12.2.
- No code, output field or pricing change.

#### 0.1.5 — 2026-09-28

- The input form starts at 20 announcements (was 200), so a first run costs about $0.08 instead of $0.80; an API call without `maxResults` still gets 500. The `filingId` and `filingSource` descriptions now say they belong to financial results.

#### 0.1 — 2026-09-10

- Initial release: `announcements`, `financial_results` (integrated and legacy feeds, optional XBRL key figures), `corporate_actions` and `equity_list` from NSE's public JSON endpoints and archive files. Current ISIN from NSE's equity list with `isinSource` on every row, three attempts at the equity list and a `degraded` summary row when it still fails, symbol validation with suggestions, explicit empty / blocked / invalid-input summary rows, default automatic Apify Proxy, one `filing-record` event per data row.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/india-listed-company-filings/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Pick one feed per run. Announcements are the daily stream of company disclosures with PDF links; financial results are quarterly (turn on XBRL figures to get revenue, profit and EPS as numbers); corporate actions are dividends, splits, bonus, rights and buybacks; the equity list is every NSE-listed company with its ISIN.

## `symbols` (type: `array`):

NSE trading symbols such as INFY, TCS or RELIANCE — not company names or BSE codes. Each symbol is checked against NSE's official equity list; an unknown symbol produces an error row instead of a silent empty run (if the list cannot be loaded in a run, symbols are used as given and the run says so in a 'degraded' summary row). For financial results and corporate actions, a symbol returns that company's full filing history unless you choose a custom date range.

## `datePreset` (type: `string`):

Quick filter. Pick 'Custom' to use the From/To fields below. For financial results and corporate actions this only applies to market-wide runs or when set to Custom — a symbol returns full history otherwise.

## `dateFrom` (type: `string`):

Start date as YYYY-MM-DD, e.g. 2026-08-01. Only used when Date range is 'Custom'.

## `dateTo` (type: `string`):

End date as YYYY-MM-DD. Leave empty for today. A future date lists upcoming corporate-action ex-dates.

## `keyword` (type: `string`):

Keep only rows whose subject, description, company name or purpose contains this text (case-insensitive), e.g. 'dividend', 'resignation', 'order', 'buyback'. Leave empty for everything.

## `includeXbrl` (type: `boolean`):

Download each result's official XBRL document from NSE's archive and add revenue, total income, total expenses, profit before tax, tax, net profit, EPS and paid-up capital, plus total assets and equity on March and September filings (the ones that carry a balance sheet). One extra archive download per result — in testing, 42 filings took 49 requests and 26.5 MB (year-end files with full segment data are the large ones). Figures are absolute INR as filed; a tag the filing does not carry stays null (bank filings have no total-expenses or equity element).

## `maxResults` (type: `integer`):

Stop after this many data rows. Helps control cost — one filing-record event is charged per data row. Set to 0 for unlimited. The form starts at 20; an API call without this field gets 500.

## `requestDelayMs` (type: `integer`):

Pause after every request to NSE. Minimum 700 ms (lower values are raised to 700); raise it for very large custom ranges.

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

Keep the default automatic Apify Proxy. NSE's edge network refuses some IP addresses with HTTP 403; the actor then retries once from a fresh IP and, if refused again, says so in the dataset. In testing, residential IPs were refused more often than the automatic pool, so the fix for a block is simply to run again. No cookie or browser-fingerprint tricks are used.

## Actor input object example

```json
{
  "mode": "announcements",
  "datePreset": "last_7_days",
  "includeXbrl": false,
  "maxResults": 20,
  "requestDelayMs": 700,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "mode": "announcements",
    "datePreset": "last_7_days",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/india-listed-company-filings").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 = {
    "mode": "announcements",
    "datePreset": "last_7_days",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/india-listed-company-filings").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 '{
  "mode": "announcements",
  "datePreset": "last_7_days",
  "maxResults": 20
}' |
apify call foxlabs/india-listed-company-filings --silent --output-dataset

```

## MCP server setup

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

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/DnaIuV5Rh8eoyEaO0/builds/I1XQgs5VYQPRtGJPJ/openapi.json