# Macrotrends Scraper (`crawlerbros/macrotrends-scraper`) Actor

Scrape Macrotrends.net for historical financial data including stock prices, revenue, earnings, PE ratios, and macroeconomic indicators for thousands of stocks and economic metrics

- **URL**: https://apify.com/crawlerbros/macrotrends-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Macrotrends Scraper

Extract historical financial data from [Macrotrends.net](https://www.macrotrends.net) — covering stock price history, revenue, earnings per share, net income, P/E ratios, and macroeconomic indicators for thousands of publicly traded companies and economic metrics dating back decades.

### What This Actor Does

This actor scrapes Macrotrends.net to retrieve:
- **Stock Price History** — Daily data aggregated to monthly, quarterly, or annual OHLCV (open, high, low, close, volume) prices
- **Revenue** — Quarterly and annual revenue figures for any publicly listed company
- **Earnings Per Share** — Diluted EPS data on a quarterly or annual basis
- **Net Income** — Quarterly and annual net income figures
- **P/E Ratio History** — Historical price-to-earnings ratios
- **Macroeconomic Indicators** — Federal Funds Rate, 10-Year Treasury Rate, GDP, inflation, unemployment, and S&P 500 returns

### Input Configuration

| Parameter | Type | Description |
|-----------|------|-------------|
| `mode` | String (required) | What data to fetch. Options: `stockPrice`, `revenue`, `earnings`, `netIncome`, `peRatio`, `macroIndicators` |
| `ticker` | String | Stock ticker symbol (e.g. `AAPL`, `MSFT`, `TSLA`). Required for stock/fundamental modes |
| `frequency` | String | Data granularity: `monthly`, `quarterly`, or `annual` |
| `indicator` | String | Macro indicator for `macroIndicators` mode (e.g. `fed-funds-rate`) |
| `fromYear` | Integer | Filter stock price history from this year (e.g. `2020`) |
| `toYear` | Integer | Filter stock price history up to this year (e.g. `2024`) |
| `maxItems` | Integer | Maximum number of records to return (1–10,000, default 500) |

#### Available Modes

- **`stockPrice`** — Historical OHLCV stock prices with moving averages
- **`revenue`** — Income statement revenue (quarterly or annual)
- **`earnings`** — EPS diluted (quarterly or annual)
- **`netIncome`** — Net income (quarterly or annual)
- **`peRatio`** — Price-to-earnings ratio history
- **`macroIndicators`** — Economic indicators

#### Available Macro Indicators

| Indicator | Description |
|-----------|-------------|
| `fed-funds-rate` | Federal Reserve target interest rate |
| `us-10-year-treasury-rate` | 10-Year US Treasury bond yield |
| `us-gdp` | US GDP growth rate |
| `us-inflation-rate` | US Consumer Price Index inflation rate |
| `us-unemployment-rate` | US unemployment rate |
| `sp500-historical-returns` | S&P 500 index historical returns |

### Output Fields

Each record includes:

| Field | Type | Description |
|-------|------|-------------|
| `ticker` | String | Stock ticker symbol (stock/fundamental modes) |
| `indicator` | String | Macro indicator name (macroIndicators mode) |
| `date` | String | Date in YYYY-MM-DD format |
| `frequency` | String | Data frequency (monthly/quarterly/annual) |
| `metricName` | String | Human-readable metric name |
| `value` | Number | Primary metric value (close price, revenue, EPS, etc.) |
| `open` | Number | Opening price (stockPrice mode only) |
| `high` | Number | Daily high price (stockPrice mode only) |
| `low` | Number | Daily low price (stockPrice mode only) |
| `close` | Number | Closing price (stockPrice mode only) |
| `volume` | Number | Trading volume in millions (stockPrice mode only) |
| `unit` | String | Unit of measurement (e.g. "Billions USD", "%") |
| `source` | String | Always "Macrotrends" |
| `metricUrl` | String | Direct URL to the Macrotrends page |
| `scrapedAt` | String | ISO 8601 timestamp when the record was scraped |

### Example Use Cases

#### Get Apple Stock Price History (Last 5 Years Monthly)
```json
{
  "mode": "stockPrice",
  "ticker": "AAPL",
  "frequency": "monthly",
  "fromYear": 2020,
  "maxItems": 60
}
````

#### Get Tesla Quarterly Revenue

```json
{
  "mode": "revenue",
  "ticker": "TSLA",
  "frequency": "quarterly",
  "maxItems": 20
}
```

#### Get Federal Funds Rate History

```json
{
  "mode": "macroIndicators",
  "indicator": "fed-funds-rate",
  "frequency": "monthly",
  "maxItems": 120
}
```

### Frequently Asked Questions

**Q: What stocks are available?**
A: All stocks listed on major US exchanges (NYSE, NASDAQ, etc.) are available. Simply use the ticker symbol (AAPL, GOOGL, AMZN, TSLA, etc.).

**Q: How far back does the data go?**
A: Stock price history is available from the company's IPO date. For well-established companies like Apple, data goes back to 1980. Macro economic indicators often go back 50+ years.

**Q: How often is the data updated?**
A: Macrotrends updates stock data daily and fundamentals quarterly (following earnings releases).

**Q: Can I get daily stock prices?**
A: The actor retrieves daily data and aggregates it. Use `frequency: "monthly"` for 1 record per month, `"quarterly"` for one per quarter, or `"annual"` for one per year.

**Q: Are P/E ratios adjusted for splits?**
A: Macrotrends provides split-adjusted historical data.

**Q: What currencies are revenue/net income in?**
A: Revenue and net income are reported in billions USD by default (as Macrotrends provides them).

**Q: Is proxy or authentication required?**
A: No. This actor uses browser impersonation (curl\_cffi) to access public Macrotrends pages. No authentication is required.

# Actor input Schema

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

What type of data to fetch.

## `ticker` (type: `string`):

Stock ticker symbol (e.g. AAPL, MSFT, TSLA). Required for stock/fundamental modes.

## `frequency` (type: `string`):

Time granularity of the returned data. For stock prices: monthly/quarterly/annual. For fundamentals: quarterly/annual. For macro indicators: monthly.

## `indicator` (type: `string`):

Economic indicator to fetch (mode=macroIndicators only).

## `fromYear` (type: `integer`):

Filter stock price history to records from this year onward (inclusive).

## `toYear` (type: `integer`):

Filter stock price history to records up to this year (inclusive).

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

Maximum number of records to return.

## Actor input object example

```json
{
  "mode": "stockPrice",
  "ticker": "AAPL",
  "frequency": "monthly",
  "indicator": "fed-funds-rate",
  "maxItems": 24
}
```

# Actor output Schema

## `financialData` (type: `string`):

Dataset containing all scraped financial data records.

# 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": "stockPrice",
    "ticker": "AAPL",
    "frequency": "monthly",
    "indicator": "fed-funds-rate",
    "maxItems": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/macrotrends-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 = {
    "mode": "stockPrice",
    "ticker": "AAPL",
    "frequency": "monthly",
    "indicator": "fed-funds-rate",
    "maxItems": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/macrotrends-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "stockPrice",
  "ticker": "AAPL",
  "frequency": "monthly",
  "indicator": "fed-funds-rate",
  "maxItems": 24
}' |
apify call crawlerbros/macrotrends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/macrotrends-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Macrotrends Scraper",
        "description": "Scrape Macrotrends.net for historical financial data including stock prices, revenue, earnings, PE ratios, and macroeconomic indicators for thousands of stocks and economic metrics",
        "version": "1.0",
        "x-build-id": "XX5A9gIuza0QGA4Yb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~macrotrends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-macrotrends-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~macrotrends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-macrotrends-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~macrotrends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-macrotrends-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "stockPrice",
                            "revenue",
                            "earnings",
                            "netIncome",
                            "peRatio",
                            "macroIndicators"
                        ],
                        "type": "string",
                        "description": "What type of data to fetch.",
                        "default": "stockPrice"
                    },
                    "ticker": {
                        "title": "Stock Ticker",
                        "type": "string",
                        "description": "Stock ticker symbol (e.g. AAPL, MSFT, TSLA). Required for stock/fundamental modes.",
                        "default": "AAPL"
                    },
                    "frequency": {
                        "title": "Data Frequency",
                        "enum": [
                            "monthly",
                            "quarterly",
                            "annual"
                        ],
                        "type": "string",
                        "description": "Time granularity of the returned data. For stock prices: monthly/quarterly/annual. For fundamentals: quarterly/annual. For macro indicators: monthly.",
                        "default": "monthly"
                    },
                    "indicator": {
                        "title": "Macro Indicator",
                        "enum": [
                            "fed-funds-rate",
                            "us-10-year-treasury-rate",
                            "us-gdp",
                            "us-inflation-rate",
                            "inflation-rate-by-year",
                            "us-unemployment-rate",
                            "sp500-historical-returns",
                            "gold-price",
                            "oil-prices"
                        ],
                        "type": "string",
                        "description": "Economic indicator to fetch (mode=macroIndicators only).",
                        "default": "fed-funds-rate"
                    },
                    "fromYear": {
                        "title": "From Year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Filter stock price history to records from this year onward (inclusive)."
                    },
                    "toYear": {
                        "title": "To Year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Filter stock price history to records up to this year (inclusive)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 500
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
