# Stock Earnings Calendar Scraper (Multi-Source) (`risky_doughnut/stock-earnings-calendar-scraper`) Actor

Scrape stock earnings dates from multiple independent financial sources. Compare results across providers with Best, All, or Custom source modes.

- **URL**: https://apify.com/risky\_doughnut/stock-earnings-calendar-scraper.md
- **Developed by:** [Brook N](https://apify.com/risky_doughnut) (community)
- **Categories:** Open source
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 earnings results

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

## Stock Earnings Calendar Scraper (Multi-Source)

### 1. Summary

Scrapes earnings dates from multiple independent financial-data sources so users can compare reported earnings dates across providers.

The Actor currently supports **7 verified production sources**:

- Benzinga
- Earnings Whispers
- Investing.com
- Nasdaq
- TipRanks
- TradingView
- Wall Street Numbers

Additional scraper integrations are under development.

The Actor supports CSV input, dataset input, or manual tickers.

Results are returned as clean, flattened earnings-date rows in the default dataset.

Because earnings dates can differ between financial-data providers, the Actor can query multiple independent sources rather than relying on a single provider. Users can choose between **Best Sources**, **All Sources**, or a **Custom** selection.

The Actor also supports optional **incidental calendar results**. When enabled, calendar-based sources may return valid earnings events discovered during their calendar scan even when those tickers were not explicitly requested. This can provide additional earnings-calendar coverage without requiring a separate scan.

### 2. Source Modes

Normal production runs support three source modes.

#### 2.1. Best Sources

**Best Sources** is the recommended default.

It uses the verified sources that currently provide the strongest combination of reliability, speed, and operating cost.

Current Best Sources:

- TradingView
- Nasdaq
- Investing.com
- Benzinga

#### 2.2. All Sources

**All Sources** uses every currently verified production source.

Current All Sources execution order:

- TradingView
- Nasdaq
- Investing.com
- Wall Street Numbers
- Benzinga
- TipRanks
- Earnings Whispers

This mode provides maximum cross-source coverage and is useful when you want to compare earnings dates reported by as many supported providers as possible.

Because it includes slower and more resource-intensive sources, All Sources may take significantly longer and cost more to run than Best Sources.

#### 2.3. Custom Sources

**Custom Sources** lets you select individual production sources.

Use this mode when you only want results from particular providers.

### 3. Source Availability

| Source              | Best Sources | All Sources | Custom |
| ------------------- | :----------: | :---------: | :----: |
| TradingView         |       ✓      |      ✓      |    ✓   |
| Nasdaq              |       ✓      |      ✓      |    ✓   |
| Investing.com       |       ✓      |      ✓      |    ✓   |
| Benzinga            |       ✓      |      ✓      |    ✓   |
| Earnings Whispers   |       —      |      ✓      |    ✓   |
| TipRanks            |       —      |      ✓      |    ✓   |
| Wall Street Numbers |       —      |      ✓      |    ✓   |

The Best Sources preset may change over time as source reliability, performance, or availability changes.

All Sources includes every source that has been verified for current production use.

### 4. Input Methods

The Actor automatically detects which ticker input method you use.

#### 4.1. CSV Upload

Upload or paste a CSV with one ticker per line.

A header is optional.

Example:

```text
ticker
AAPL
MSFT
NVDA
```

#### 4.2. Dataset ID

If your tickers are stored in an Apify dataset, provide the `datasetId`.

#### 4.3. Manual Tickers

Enter tickers manually in the Actor input UI.

**NOTE:** If no ticker input is supplied, the Actor attempts to load the local `tickers` dataset and otherwise falls back to `AAPL`.

### 5. Input Fields

`csv` — Paste CSV content (optional)

`datasetId` — Use an Apify dataset containing tickers (optional)

`tickers` — Manual ticker list (optional)

`sourceMode` — Select the production source strategy:

- `best` — Best Sources (recommended)
- `all` — All verified production sources
- `custom` — Use only the sources individually selected under Custom Sources

`includeIncidental` — Include additional valid earnings events discovered by calendar-based sources while processing the requested tickers.

- `false` — Return results for requested tickers only (default)
- `true` — Also return valid incidental ticker/date results discovered during calendar scans

Incidental results use the same normalized output format as requested results and are limited to the source's current earnings-calendar window.

Not every source can provide incidental results. Sources that retrieve earnings information directly for individual requested tickers continue to return requested-ticker results only.

When `sourceMode` is set to `custom`, select one or more individual sources under **Custom Sources**.

### 6. Earnings-Date Coverage

Different sources may use different earnings-calendar architectures and coverage windows.

Some sources scan a forward earnings-calendar window, while others retrieve the next reported earnings event for an individual ticker.

Calendar-based sources may discover earnings events for additional tickers while scanning their calendar window. When `includeIncidental` is enabled, these valid incidental results may also be returned. When it is disabled, the Actor returns results only for the explicitly requested tickers.

Incidental-result support depends on the architecture and coverage of each source. A source that performs direct ticker lookups may not discover additional tickers.

As a result, one source may return an earnings date that another source does not.

This is expected and is one of the reasons the Actor supports multiple independent sources.

The Actor does not treat disagreement between providers as an error. Each valid source result is returned independently so you can compare the available dates.

### 7. Output

#### Normal Production Mode

All valid scraped results are pushed to the default dataset in normalized JSON format.

Each source result is returned independently.

Typical output:

```json
{
  "ticker": "ORCL",
  "date": "2026-09-10",
  "source": "TradingView"
}
```

If several sources report dates for the same ticker, multiple rows may therefore be returned.

When `includeIncidental` is enabled, the dataset may also contain valid ticker/date rows discovered during calendar scans even if those tickers were not part of the original input.

Incidental rows use exactly the same output schema:

```json
{
  "ticker": "XYZ",
  "date": "2026-09-15",
  "source": "Nasdaq"
}
```

The output does not include a separate incidental field. Requested and incidental observations use the same ticker, date, and source structure.

### 8. Choosing a Source Mode

For most workloads, start with **Best Sources**.

Use **All Sources** when maximizing independent source coverage and comparing provider disagreement is more important than runtime or cost.

Use **Custom Sources** when you already know which providers you want to query.

### 9. Broader Source Evaluation

Production sources were selected after testing a wider range of financial-data providers and integration approaches.

In addition to the 7 production sources, additional integration efforts are underway.

# Actor input Schema

## `csv` (type: `string`):

Paste CSV content here. One ticker per line. Header optional.

## `datasetId` (type: `string`):

If your backend uploads a CSV to an Apify dataset, enter its datasetId here.

## `tickers` (type: `array`):

Enter tickers manually if not using CSV or dataset.

## `sourceMode` (type: `string`):

Choose Best Sources for the recommended optimized set, All Sources for maximum verified cross-source coverage, or Custom Sources to enable individual providers below.

## `includeIncidental` (type: `boolean`):

Also return valid earnings dates discovered during calendar scans for tickers that were not explicitly requested. Results remain limited to the current earnings window.

## `customTradingview` (type: `boolean`):

Enable TradingView when Source Mode is Custom Sources.

## `customNasdaq` (type: `boolean`):

Enable Nasdaq when Source Mode is Custom Sources.

## `customInvesting` (type: `boolean`):

Enable Investing.com when Source Mode is Custom Sources.

## `customWallstreet` (type: `boolean`):

Enable Wall Street Numbers when Source Mode is Custom Sources.

## `customBenzinga` (type: `boolean`):

Enable Benzinga when Source Mode is Custom Sources.

## `customTipranks` (type: `boolean`):

Enable TipRanks when Source Mode is Custom Sources.

## `customEw` (type: `boolean`):

Enable Earnings Whispers when Source Mode is Custom Sources.

## Actor input object example

```json
{
  "sourceMode": "best",
  "includeIncidental": false,
  "customTradingview": false,
  "customNasdaq": false,
  "customInvesting": false,
  "customWallstreet": false,
  "customBenzinga": false,
  "customTipranks": false,
  "customEw": false
}
```

# Actor output Schema

## `items` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("risky_doughnut/stock-earnings-calendar-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("risky_doughnut/stock-earnings-calendar-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 '{}' |
apify call risky_doughnut/stock-earnings-calendar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,risky_doughnut/stock-earnings-calendar-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/b4ER66171vjBemjax/builds/RbBk1xTusPedGKxA9/openapi.json