# Stock Earnings Estimates & Results: EPS Forecast vs Actual (`scrapemint/stock-earnings-estimates`) Actor

Keyless earnings data for any US stock from NASDAQ: what analysts expect the company to earn next quarter, what it actually earned in past quarters, the percentage it beat or missed by, how often it has beaten, and whether analysts raised or cut their forecast in the last four weeks. Pay per row.

- **URL**: https://apify.com/scrapemint/stock-earnings-estimates.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Stock Earnings Estimates & Results: EPS Forecast vs Actual

Keyless **earnings data** for any US stock, from **NASDAQ**. No API key, no account, no terminal subscription.

Public companies report earnings every quarter. Before each report, analysts publish the earnings per share they expect. After it, you can see what the company actually delivered. This puts both sides side by side, and adds the part most sources leave out: **whether analysts are raising or cutting their forecast right now**.

- **Summary** — one row per ticker: next quarter's consensus, what last quarter actually delivered against expectations, how often the company has beaten across its recent reports, and how many analysts raised versus cut their number in the last four weeks.
- **Surprises** — one row per reported quarter: actual EPS, the consensus it was measured against, the dollar and percentage difference, and whether it was a beat, a miss or inline.
- **Forecasts** — one row per forecast period, quarterly and annual, with the high estimate, the low estimate and how many analysts contributed.

A summary row for NVDA reads: analysts expect **$2.01** next quarter, last quarter it earned **$1.87** against a **$1.70** expectation for a **+10%** surprise, it has beaten in **4 of its last 4** reports, and in the last four weeks **3 analysts raised** their forecast and **none cut**.

### Who uses it

- **Investors sizing up an earnings date** — a company that reliably beats and has rising estimates is a different setup from one that keeps missing.
- **Swing and options traders** — earnings are the single biggest scheduled volatility event a stock has, and this is the expectation it will be measured against.
- **Screeners and newsletters** — filter to serial beaters, or to every name whose estimates are being revised upward, and publish the list.
- **Analysts and finance teams** — pull the consensus, high and low estimate for a peer group without a data terminal.

Pairs with our [Stock Earnings Calendar](https://apify.com/scrapemint/stock-earnings-calendar-scraper) for **when** a company reports, [Stock Analyst Ratings](https://apify.com/scrapemint/stock-analyst-ratings) for price targets, and [Institutional Ownership Tracker](https://apify.com/scrapemint/institutional-ownership-tracker) for who owns it.

### Input

| Field | Description |
|-------|-------------|
| `mode` | `summary`, `surprises`, or `forecasts`. |
| `symbols` | US tickers, e.g. `NVDA`, `TSLA`, `AAPL`. Max 200 per run. |
| `minBeatRate` | Keep only companies beating in at least this share of reported quarters. |
| `onlyRaisedEstimates` | Keep only tickers where more analysts raised than cut in the last four weeks. |
| `includeAnnual` | Include full year forecasts alongside quarterly ones. |
| `maxRows` | Row cap per run. |

### Output

- **Summary**: `symbol`, `nextFiscalPeriodEnd`, `nextQuarterConsensusEps`, `nextQuarterHighEps`, `nextQuarterLowEps`, `analystEstimateCount`, `revisionsUp`, `revisionsDown`, `netRevisions`, `estimatesRising`, `lastFiscalQuarterEnd`, `lastDateReported`, `lastActualEps`, `lastConsensusEps`, `lastSurprisePercent`, `lastResult`, `quartersReported`, `beatCount`, `missCount`, `beatRatePercent`, `averageSurprisePercent`, `currentYearConsensusEps`.
- **Surprises**: `symbol`, `fiscalQuarterEnd`, `dateReported`, `actualEps`, `consensusEps`, `surpriseAmount`, `surprisePercent`, `result`.
- **Forecasts**: `symbol`, `period`, `fiscalPeriodEnd`, `consensusEps`, `highEps`, `lowEps`, `estimateRange`, `estimateCount`, `revisionsUp`, `revisionsDown`, `netRevisions`.

### Notes on the data

- **Beat or miss is computed from the numbers, not just read off the published percentage.** Actual EPS is compared against the consensus it was measured against, and the published percentage is used only as a fallback, so a missing field never voids the verdict.
- The history covers a company's **recent reported quarters**, typically four, which is what NASDAQ publishes. `quartersReported` tells you how many were actually available rather than assuming four.
- Estimates are **as of now**, so a run captures the consensus at the moment it executes. Schedule it if you want to watch a number drift ahead of a report.
- **EPS figures are as reported by the source**, which for most companies means adjusted rather than GAAP earnings. That is the number the consensus is set against, so the comparison is consistent even though it is not the GAAP figure in the filing.
- A ticker with no analyst coverage or no reported history returns a free note row rather than an error.

### Pricing

Pay per event: **$0.005 per row**. The first 2 rows of every run are free.

Data source: NASDAQ earnings surprise and analyst forecast endpoints (`api.nasdaq.com`).

# Actor input Schema

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

summary = one row per ticker: what analysts expect next quarter, what the company delivered last quarter, how often it has beaten, and whether estimates are being raised or cut. surprises = one row per reported quarter. forecasts = one row per forecast period.

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

US tickers to look up, e.g. NVDA, TSLA, AAPL. Maximum 200 per run.

## `minBeatRate` (type: `integer`):

Keep only companies that beat expectations in at least this share of their reported quarters. 75 returns serial beaters. 0 = no filter.

## `onlyRaisedEstimates` (type: `boolean`):

Keep only tickers where more analysts raised their forecast than cut it in the last four weeks. Estimate revision direction is the forward looking half of this data.

## `includeAnnual` (type: `boolean`):

Return full year estimates alongside the quarterly ones.

## `maxRows` (type: `integer`):

Cap on rows returned across all tickers. Controls total cost.

## Actor input object example

```json
{
  "mode": "summary",
  "symbols": [
    "NVDA",
    "TSLA",
    "AAPL",
    "MSFT",
    "AMD",
    "AMZN",
    "GOOGL",
    "META"
  ],
  "minBeatRate": 0,
  "onlyRaisedEstimates": false,
  "includeAnnual": true,
  "maxRows": 200
}
```

# 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 = {
    "symbols": [
        "NVDA",
        "TSLA",
        "AAPL",
        "MSFT",
        "AMD",
        "AMZN",
        "GOOGL",
        "META"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/stock-earnings-estimates").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 = { "symbols": [
        "NVDA",
        "TSLA",
        "AAPL",
        "MSFT",
        "AMD",
        "AMZN",
        "GOOGL",
        "META",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/stock-earnings-estimates").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 '{
  "symbols": [
    "NVDA",
    "TSLA",
    "AAPL",
    "MSFT",
    "AMD",
    "AMZN",
    "GOOGL",
    "META"
  ]
}' |
apify call scrapemint/stock-earnings-estimates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapemint/stock-earnings-estimates"
        }
    }
}

```

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/LFruwukcjFJ1SUrM0/builds/aiTCrvj193EKaZsLC/openapi.json