# FRED Economic Data Scraper (`parseforge/fred-scraper`) Actor

Scrapes FRED economic data series by search query or category ID. Returns series metadata and optional historical observations as flat rows.

- **URL**: https://apify.com/parseforge/fred-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Automation
- **Features:** Limited permissions
- **Stats:** 18 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 results

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### FRED Economic Data Scraper

**Scrape FRED economic data series by search term, category, or frequency, up to a million per run.** Each series returns its ID, title, units, seasonal adjustment, and popularity, with optional historical observations. No API key required. Export to CSV, JSON, Excel, or XML.

The FRED API requires a registered key and rate-limits requests. This scraper reads the public series catalog directly, letting you search by keyword, filter by category, frequency, units, and seasonal adjustment, and return matching economic data series in a flat, consistent schema. It handles pagination and optional observation fetching so you get clean data without writing a single request.

| Who uses it | What they scrape FRED for |
|---|---|
| Economists | Pull the latest CPI, GDP, or employment series for a research paper. |
| Financial analysts | Gather interest rate and inflation series to feed into a market model. |
| Data journalists | Collect multiple economic indicators to fact-check a story on wage growth. |
| Academic researchers | Build a dataset of production and business activity series for a longitudinal study. |

### What it does

This Actor collects FRED economic data series metadata by search query or category ID and returns each series as a flat row, with optional historical observations.

- 🔍 **Full-text search:** Find series by keyword across titles, units, frequency, and tags.
- 📂 **Category filter:** Restrict results to a specific FRED category like National Accounts or Prices.
- 📊 **Observation download:** Optionally fetch every historical date-value pair for each matched series.
- 📋 **Fixed schema:** Every series row has the same fields, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with FRED data

**📈 Monitor inflation indicators.**

An economist searches for 'cpi' with monthly frequency and seasonally adjusted units to track consumer price changes over time.

**🏭 Track production and business activity.**

A researcher filters by category ID 1 and frequency 'Monthly' to collect industrial production series for a manufacturing report.

**💼 Build a labor market dashboard.**

A financial analyst pulls all unemployment-related series, sorted by popularity, to feed a weekly jobs market update.

**📚 Gather data for academic research.**

A PhD student collects GDP and national accounts series with full historical observations for a macroeconomics dissertation.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Reads the public catalog without registration or rate limits. |
| **Flexible filtering** | Combine search text, category, frequency, units, and seasonal adjustment in one run. |
| **Observation data** | Optionally pull the full time series of date-value pairs for each series. |
| **Sort control** | Order results by popularity, last update, observation range, or search rank. |

### How it compares

No other Store actor targets FRED the same way, so the honest comparison is with the alternatives teams actually weigh.

| | FRED Economic Data Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When FRED changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with a search term or a category ID, then narrow results by frequency, units, and seasonal adjustment before the data reaches your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "searchText": "cpi"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "searchText": "cpi"
}
```

### Pricing

Pay-per-result: **$0.00675 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.68 |
| 1,000 results | $6.75 |
| 10,000 results | $67.50 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [FRED Economic Data Scraper](https://apify.com/parseforge/fred-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to FRED through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/fred-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**I am getting no results for my search term.**

Try a broader or shorter keyword. FRED search matches against series titles, units, and tags. Check that your frequency, units, or seasonal adjustment filters are not too restrictive and excluding all matches.

**The run is taking a very long time.**

If you have 'Include Observations' enabled, the Actor fetches every historical data point for each series. Reduce the 'Maximum series' count or disable observations to speed up the run.

**My category filter is not working.**

Verify the category ID is correct. You can find the numeric ID at the end of the category URL on the FRED website. Also, ensure you have not combined it with a search term that returns no results within that category.

**The sort order seems wrong.**

Check the 'Sort Order' and 'Order By' fields. The default is 'search_rank' in descending order. If you change the sort field, make sure the direction is set as you expect.

### FAQ

| Question | Answer |
|---|---|
| Do I need a FRED API key to use this scraper? | No. This Actor reads the public FRED web catalog directly, so you do not need to register for an API key or worry about rate limits. |
| What is the difference between series metadata and observations? | Series metadata includes the title, ID, units, frequency, and seasonal adjustment. Observations are the actual historical date-value pairs. You can choose to include observations by checking the 'Include Observations' box, but it will increase the run time. |
| How do I find the right category ID? | You can browse categories on the FRED website. The ID is the number in the URL. For example, category ID 10 is National Accounts, and ID 1 is Production & Business Activity. |
| Can I search for multiple terms at once? | The search text field accepts a single query string, which FRED uses for a full-text search across series titles, units, and tags. For multiple distinct searches, run the Actor multiple times with different terms. |
| Why does fetching observations take so long? | Each series can have decades of daily, weekly, or monthly data. The Actor fetches all historical observations for every matched series, which requires a separate request per series and can take several minutes for large result sets. |
| What export formats are supported? | You can export your results to CSV, JSON, Excel, or XML directly from the Apify dataset. |
| How many series can I collect in one run? | You can set the maximum up to 1,000,000 series. The Actor will stop when it reaches that limit or when there are no more matching series. |
| Can I filter by seasonal adjustment? | Yes. You can choose 'Seasonally Adjusted' or 'Not Seasonally Adjusted' from the dropdown to narrow your results. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Federal Reserve Bank of St. Louis. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many data series to collect per run.

## `searchText` (type: `string`):

Full-text search query to find economic data series. Searches across series titles, units, frequency, and tags. Example: 'cpi', 'unemployment', 'gdp'

## `categoryId` (type: `integer`):

Filter results by FRED category ID. Example: 10 (National Accounts), 1 (Production & Business Activity)

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

Filter by data frequency

## `units` (type: `string`):

Filter by units of measurement

## `seasonalAdjustment` (type: `string`):

Filter by seasonal adjustment

## `includeObservations` (type: `boolean`):

Whether to include observation data (date-value pairs) for each series. ⚠️ WARNING: This will significantly increase processing time and cost. The scraper fetches all historical observations for each series, which requires additional API requests and may take several minutes for large datasets.

## `sortOrder` (type: `string`):

Field to sort results by

## `orderBy` (type: `string`):

Sort order direction

## Actor input object example

```json
{
  "maxItems": 10,
  "searchText": "cpi",
  "includeObservations": false,
  "sortOrder": "search_rank",
  "orderBy": "desc"
}
```

# Actor output Schema

## `results` (type: `string`):

Complete dataset with all scraped FRED series including metadata and observations

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

Overview view of FRED series with key fields displayed in a table format

# 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 = {
    "maxItems": 10,
    "searchText": "cpi"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fred-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 = {
    "maxItems": 10,
    "searchText": "cpi",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/fred-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 '{
  "maxItems": 10,
  "searchText": "cpi"
}' |
apify call parseforge/fred-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/fred-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/fFQVxMOPIht71gWb7/builds/FOVSedme8UkZQiH0A/openapi.json