# Screener.in Company Financials Scraper (`automation-lab/screener-in-company-financials`) Actor

Search Indian listed companies and export public consolidated financial statements, ratios and shareholding tables from Screener.in, with period labels, units and source links.

- **URL**: https://apify.com/automation-lab/screener-in-company-financials.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 item extracteds

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

## Screener.in Company Financials Scraper

Export **Screener.in company financials** for recurring Indian equity research.
Search by company name or supply company URLs to collect public consolidated
identity, market metrics, quarterly results, annual profit and loss, balance
sheets, cash flow, ratios and shareholding history in one structured bundle
per company.

This is for analysts maintaining valuation workbooks, researchers refreshing
issuer fundamentals, and portfolio teams comparing public reporting periods.
It does not require a Screener account or export premium content.

### What does this Actor extract?

| Data | Output |
| --- | --- |
| Company identity | Source ID, name, URL identifier, NSE symbol and BSE code when linked |
| Market metrics | Visible top-ratio labels and source text including units |
| Quarterly results | Public consolidated table with original periods |
| Annual results | Profit and loss, including TTM when exposed |
| Balance sheet | Visible consolidated asset and liability rows |
| Cash flow | Visible operating, investing and financing rows |
| Ratios | Public table with days, percentages and established units |
| Shareholding | Public category percentages and shareholder counts |

Each financial cell preserves its source text as well as a parsed number.
Amounts stay in INR crore; the Actor does not convert currencies or scales.
EPS uses INR/share, percentages stay as percentage points (72.41 means 72.41%),
and shareholder counts remain counts. Unknown ratio units are null.

### Who is it for?

Use these records for issuer-comparison workbooks, fundamental research and
portfolio reporting refreshes. This tool is not a trading signal service.

### Why use this Actor?

A company bundle keeps identity and reporting basis beside the financial
history, avoiding ambiguous piles of standalone cells. Period labels and
source URLs support spreadsheet joins and audit trails. Blank source cells
remain null rather than becoming misleading zeros.

Only consolidated pages are accepted. The Actor does not silently substitute
standalone results or claim that every listed issuer publishes every section.

### Getting started

1. Keep the prefilled TCS company URL for a first run, or enter company searches.
2. Set **Maximum companies** to the number of company bundles needed.
3. Run the Actor and inspect the default dataset's Company financials view.
4. Download JSON for nested tables, or transform the rows into your workbook.
5. Use an Apify schedule if you want recurring snapshots. Store and compare
   snapshots downstream; this Actor does not send change alerts itself.

### Input parameters

| Field | Meaning |
| --- | --- |
| `startUrls` | Up to 25 objects containing public Screener company URLs |
| `queries` | Up to ten company-name or symbol searches, each 1–100 characters |
| `maxItems` | Global distinct-company limit; default 3, minimum 1, maximum 25 |

At least one URL or search query is required. Queries are trimmed and sent to
Screener autocomplete; source-ranked suggestions are not exact-match filters.
A query may return fewer suggestions than the requested limit. This is not an
exhaustive exchange-wide financial screening or custom screener-query service.

Explicit URLs take precedence. Duplicates are normalized to the same
consolidated URL. Search discovery fills remaining places in input order and
stops at the global limit. Source suggestions pointing only to standalone
accounts are skipped. An explicit standalone-only issuer fails clearly.
No login, cookie, proxy or premium-data input is supported.

```json
{
  "queries": ["tata"],
  "maxItems": 2
}
```

For a known issuer, use:

```json
{
  "startUrls": [{"url": "https://www.screener.in/company/TCS/consolidated/"}],
  "maxItems": 3
}
```

### Output example

This shortened excerpt shows the real structure observed for TCS. Full output
includes all visible cells from each supported table, not just this excerpt.
Values are snapshots and will change with the source.

```json
{
  "sourceUrl": "https://www.screener.in/company/TCS/consolidated/",
  "companyId": "3365",
  "companyName": "Tata Consultancy Services Ltd",
  "symbol": "TCS",
  "reportingBasis": "consolidated",
  "nseSymbol": "TCS",
  "bseCode": "532540",
  "tables": [{
    "section": "profit-loss",
    "sourceUnit": "INR crore (except percentages and per-share rows)",
    "rows": [{
      "label": "Sales",
      "values": [{"period": "Mar 2026", "periodEnd": "2026-03-31", "raw": "267,021", "value": 267021, "unit": "INR crore"}]
    }]
  }]
}
```

Other top-level fields are `website`, `metrics`, `unavailableSections` and
`scrapedAt`. Source dates are preserved when available; `periodEnd` is null
where no date key exists, including TTM. `scrapedAt` is extraction time, not
an exchange quote timestamp. Website links are returned, never crawled.

### How much does it cost to extract Screener.in company financials?

Pay-per-event billing uses a **$0.005 start fee** and one **item** event per
company bundle. All included tables and cells have no separate event charge.
Rejected URLs, duplicate companies and empty search results produce no item
charge. The start fee still applies to a valid search with no matches.

| Plan | Per company |
| --- | ---: |
| FREE | $0.0046 |
| BRONZE | $0.004 |
| SILVER | $0.00312 |
| GOLD | $0.0024 |
| PLATINUM | $0.0024 |
| DIAMOND | $0.0024 |

Worked examples at BRONZE, including the start fee:

- 1 company × $0.004 + $0.005 = $0.009 total.
- 5 companies × $0.004 + $0.005 = $0.025 total.
- 25 companies × $0.004 + $0.005 = $0.105 total.

Spend tiers depend on qualifying aggregate monthly Store spend, not a private
per-Actor volume schedule. Check the current Apify pricing tab before use.
These are modeled Actor event totals, not payout guarantees; refunds,
fraud, disputes, taxes, corrections and clawbacks can affect payouts.

### Limits and failure behavior

- Public visible consolidated tables only; no premium exports or forecasts.
- No peer-comparison rows, segment drilldowns, filings or historical revisions.
- No standalone reporting mode or automatic financial advice.
- Source history length varies by issuer and section; no fixed year-count promise.
- Requests are sequential, direct HTTP; transient network errors, 429 and 5xx
  receive at most three attempts with bounded delays. No paid proxy fallback.
- A permanent block, missing company identity, standalone response or missing
  core statements fails the run. It is not reported as a successful empty export.
- A legitimate search with no consolidated suggestions succeeds with zero rows.
- Previously saved rows can remain after a later error; treat them as partial.
- Billing limits may stop collection before `maxItems`. It is an upper bound.

### Integrations

Keep JSON in S3 or a warehouse for scheduled issuer snapshots. In Make, Zapier
or n8n, trigger a downstream workflow after a successful Actor run, fetch the
default dataset, and flatten `tables[].rows[].values[]` into rows keyed by
company ID, section, label and period. Join those records in Google Sheets,
Excel or a research database. JSON preserves nested data better than CSV.

### API usage

Set `APIFY_TOKEN` in your environment; do not paste it into shared URLs.
The synchronous endpoint below is suitable for small requests. For larger
collections start asynchronously, retain the run ID, and fetch its dataset
after successful completion rather than starting duplicate runs.

```bash
curl -X POST -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  'https://api.apify.com/v2/acts/automation-lab~screener-in-company-financials/run-sync-get-dataset-items' \
  -d '{"queries":["tata"],"maxItems":2}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/screener-in-company-financials').call({ queries: ['tata'], maxItems: 2 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 2 });
console.log(items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/screener-in-company-financials').call(run_input={'queries': ['tata'], 'maxItems': 2})
items = client.dataset(run['defaultDatasetId']).list_items(limit=2).items
print(items)
```

### MCP use

For Claude Code, select this Actor explicitly:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/screener-in-company-financials'
```

Claude Desktop, Cursor, and VS Code: use the equivalent configuration below
when your client/version supports remote HTTP MCP:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/screener-in-company-financials"}}}
```

Authenticate through your client's supported Apify flow. Discover actual tool
names and argument schemas with scoped `tools/list`. Actor selection also
exposes run, dataset, key-value and abort helpers, not exactly one tool.

Example prompt: “Collect two Tata company consolidated financials, then show
annual sales periods with units and source URLs. Do not offer investment advice.”

Start an authorized run once, retain its run/storage IDs, and follow the SAME
run. `call-actor` waits at most 45 seconds (default 30); IDs are metadata, not
financial rows. If still running, use `get-actor-run` with 2/4/8-second backoff
capped at ten seconds and a total 120-second deadline. Set client timeout above
the selected server wait plus transport margin. On timeout recover the known
run instead of restarting; if its ID is unknown, report uncertainty. At the
deadline report pending with the run ID and stop. Failures and partial rows
must be described honestly.

After success, use `get-dataset-items` with explicit fields, offset and limit.
For example, process pages of 20 source rows, at most 100 rows and 64 KiB of
serialized result content admitted to model context, whichever comes first.
Enforce bytes host-side even for one oversized company bundle; omit or summarize
with disclosure. If your client cannot intercept oversized responses, do not
claim a hard byte guarantee. Track source offsets, report truncation and the
next offset, and keep full exports outside model context. These are consumer
context limits, not changes to the Actor's supported collection contract.
No universal tool-token or caching savings are promised.

### Legality

Use the applicable Apify standard terms. The Actor performs no AI inference
and sends no input or financial data to an AI model. The generated illustration
is independent branding, not a source logo.

### Data handling and support

Collected output is public issuer identity and financial data; no personal
shareholder identities are requested. Apify stores datasets, input and logs
under your account's retention settings until expiry or deletion. Delete run
storages through Apify when no longer needed. No external cache or session
store is maintained. For help, open an issue on this Actor's Apify page with
the run ID and a non-sensitive reproduction.

### Responsible use and diagnostics

Use public data responsibly, respect source terms and applicable rights, and
verify financial figures against issuer filings before making decisions.
This independent tool is not affiliated with Screener.in, NSE, BSE or any issuer.
It does not bypass account access, provide licensed premium content or guarantee
investment accuracy.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run
IDs to our private GlitchTip service for repair. Secret fields and URL queries
are removed and reports are retained for 30 days. Do not submit credentials.

### FAQ and troubleshooting

**Why did search return an unexpected company?** Screener autocomplete supplies
ranked suggestions rather than an exact ticker filter. Use an explicit company
URL when issuer identity must be exact.

**Why is a section missing?** Public coverage varies. Check `unavailableSections`;
missing annual profit/loss or balance-sheet data instead fails the run.

**Why are some values null?** Empty or nonnumeric source cells are not zeros.
Unknown units and absent period date keys also remain null.

**Can I obtain standalone accounts or peers?** No. Only the consolidated visible
financial tables described above are supported.

**What if requests are blocked?** Reduce frequency and retry later after checking
the source page. The Actor never charges an item for a blocked company, though
already delivered companies and the valid run start can have charges.

### Related Actors

For other public market datasets, see our
[TradingView Stock Screener Scraper](https://apify.com/automation-lab/tradingview-scraper)
and [Google Finance Stock Quotes Scraper](https://apify.com/automation-lab/google-finance-market-data-scraper).
These are complementary sources, not substitutes for Screener statements.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/screener-in-company-financials/changelog.md

# Actor input Schema

## `queries` (type: `array`):

Up to ten company-name or ticker searches, trimmed and sent to Screener.in autocomplete in order. Source-ranked suggestions are not exact-match filters or exhaustive screening results. Only consolidated suggestions are included. Explicit URLs take precedence, and later searches stop when the global company limit is filled.

## `startUrls` (type: `array`):

Up to 25 public HTTPS Screener.in company URLs. All are normalized to consolidated URLs and processed before searches; duplicates are removed. No query parameters, private endpoints or alternate hosts. Standalone-only companies fail rather than being substituted.

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

Global limit of distinct company bundles across explicit URLs and all searches, not financial cells or companies per query. Default 3, allowed 1–25; zero and unlimited are not supported. Source suggestion limits and billing limits may yield fewer rows.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.screener.in/company/TCS/consolidated/"
    }
  ],
  "maxItems": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Collected company identity, metrics, statements, ratios and shareholding.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.screener.in/company/TCS/consolidated/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/screener-in-company-financials").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 = { "startUrls": [{ "url": "https://www.screener.in/company/TCS/consolidated/" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/screener-in-company-financials").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 '{
  "startUrls": [
    {
      "url": "https://www.screener.in/company/TCS/consolidated/"
    }
  ]
}' |
apify call automation-lab/screener-in-company-financials --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/screener-in-company-financials"
        }
    }
}
```

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/I6jpdQVaQfpxYXxc0/builds/BeWVbnDeCdw9OjdIb/openapi.json