# FRED Economic Data (`dash_authority/fred-economic-data`) Actor

Search and retrieve economic data series from the Federal Reserve Economic Data (FRED) API. Fetch time series observations for thousands of economic indicators. Categories: economics, financial data, FRED, economic indicators.

- **URL**: https://apify.com/dash\_authority/fred-economic-data.md
- **Developed by:** [Dash Authority](https://apify.com/dash_authority) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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.

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

## FRED Economic Data

Search and retrieve economic time series from the Federal Reserve Economic Data (FRED) API. Access over 800,000 economic indicators including GDP, unemployment, inflation, interest rates, and much more.

### Features

- Search FRED's full database of 800,000+ economic time series
- Retrieve actual time series observations for any matching series
- Filter by date range to get historical or recent data
- Sort by popularity, title, or other criteria
- Free API key required — sign up at fred.stlouisfed.org
- Pure HTTP requests, no browser needed

### Use Cases

- **Financial Analysis**: Track GDP growth, CPI, PPI, and employment data to inform investment decisions.
- **Economic Forecasting**: Build predictive models using decades of historical Federal Reserve data.
- **AI Training Data**: Gather structured economic time series for fine-tuning language models or building economic agents.
- **Academic Research**: Access the definitive source for US macroeconomic statistics with full documentation.
- **Trading Signals**: Correlate economic releases with market movements for systematic trading strategies.

### Input

| Field            | Type   | Description                                              | Default |
|------------------|--------|----------------------------------------------------------|---------|
| searchText       | string | **Required.** Search keywords for economic series        | —       |
| api_key          | string | **Required.** Your FRED API key                          | —       |
| limit            | number | Maximum series to return                                 | 100     |
| sort_order       | string | Sort order: "asc" or "desc"                              | desc    |
| observation_start| string | Start date for observations (e.g. 2020-01-01)            | —       |
| observation_end  | string | End date for observations (e.g. 2024-12-31)              | —       |

### Output

Example result:

````

{
"series\_id": "GDP",
"title": "Gross Domestic Product",
"units": "Billions of Dollars",
"frequency": "Quarterly",
"seasonal\_adjustment": "Seasonally Adjusted Annual Rate",
"observation\_start": "1947-01-01",
"observation\_end": "2024-10-01",
"last\_updated": "2024-12-19 07:58:02-06",
"popularity": 93,
"notes": "BEA Account Code: A191RL. Gross domestic product (GDP), the featured measure of U.S. output, is the market value of the goods and services produced by labor and property located in the United States.",
"observations": \[
{ "date": "2024-07-01", "value": "29353.667" },
{ "date": "2024-04-01", "value": "28649.991" },
{ "date": "2024-01-01", "value": "28275.269" }
]
}

````

| Field               | Type   | Description                                             |
|---------------------|--------|---------------------------------------------------------|
| series_id           | string | FRED series identifier                                  |
| title               | string | Human-readable series title                             |
| units               | string | Measurement units (e.g. "Billions of Dollars")          |
| frequency           | string | Data frequency (Daily, Weekly, Monthly, Quarterly, etc.)|
| seasonal_adjustment | string | Seasonal adjustment method                              |
| observation_start   | string | Earliest available observation date                     |
| observation_end     | string | Most recent observation date                            |
| last_updated        | string | When the series was last updated                        |
| popularity          | number | FRED popularity rank (0-100)                            |
| notes               | string | Series description and methodology notes                |
| observations        | array  | Array of {date, value} objects (only if dates provided)  |

### Pricing

$1.50 per 1,000 results ($0.0015 per result).

### How It Works

The actor first searches the FRED API for matching series using your search text. Each search result becomes one output record. If you provide observation_start or observation_end dates, the actor then fetches the full time series observations for each matching series. This is a two-step HTTP process — search, then retrieve. A free API key from the Federal Reserve is required for every request.

### FAQ

**Where do I get an API key?**
Go to https://fred.stlouisfed.org/docs/api/api_key.html — registration is free and the key is issued instantly.

**How many observations can I get per series?**
Up to 1,000 observations per series. For very long time series (like GDP since 1947 at quarterly frequency), you may need to request in date windows.

**How many series are available?**
Over 800,000 economic time series covering US and international macroeconomic data, employment, trade, banking, and more.

**Does the search return observations automatically?**
Only if you provide observation_start or observation_end. Without date parameters, you get series metadata only (title, frequency, units, notes).

### Limits & Rate Limits

- Maximum 1,000 results per search query
- Maximum 1,000 observations per time series request
- FRED API allows 120 requests per minute with a free key
- The actor handles pagination internally when results exceed the limit
- Historical data availability varies by series — some go back to the 1940s, others start recently

# Actor input Schema

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

Search keywords to find economic data series.
## `api_key` (type: `string`):

Your free FRED API key. Get one at https://fred.stlouisfed.org/docs/api/api_key.html
## `limit` (type: `number`):

Maximum number of series to return (max 1000).
## `sort_order` (type: `string`):

Sort order for results.
## `observation_start` (type: `string`):

Start date for time series observations (ISO 8601, e.g. 2024-01-01).
## `observation_end` (type: `string`):

End date for time series observations (ISO 8601, e.g. 2025-01-01).

## Actor input object example

```json
{
  "limit": 100,
  "sort_order": "desc"
}
````

# Actor output Schema

## `results` (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("dash_authority/fred-economic-data").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("dash_authority/fred-economic-data").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 '{}' |
apify call dash_authority/fred-economic-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FRED Economic Data",
        "description": "Search and retrieve economic data series from the Federal Reserve Economic Data (FRED) API. Fetch time series observations for thousands of economic indicators. Categories: economics, financial data, FRED, economic indicators.",
        "version": "1.0",
        "x-build-id": "3UIQASO1FqpOfwYjH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dash_authority~fred-economic-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dash_authority-fred-economic-data",
                "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/dash_authority~fred-economic-data/runs": {
            "post": {
                "operationId": "runs-sync-dash_authority-fred-economic-data",
                "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/dash_authority~fred-economic-data/run-sync": {
            "post": {
                "operationId": "run-sync-dash_authority-fred-economic-data",
                "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": [
                    "searchText",
                    "api_key"
                ],
                "properties": {
                    "searchText": {
                        "title": "Search Text",
                        "type": "string",
                        "description": "Search keywords to find economic data series."
                    },
                    "api_key": {
                        "title": "FRED API Key",
                        "type": "string",
                        "description": "Your free FRED API key. Get one at https://fred.stlouisfed.org/docs/api/api_key.html"
                    },
                    "limit": {
                        "title": "Result Limit",
                        "type": "number",
                        "description": "Maximum number of series to return (max 1000).",
                        "default": 100
                    },
                    "sort_order": {
                        "title": "Sort Order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "desc"
                    },
                    "observation_start": {
                        "title": "Observation Start Date",
                        "type": "string",
                        "description": "Start date for time series observations (ISO 8601, e.g. 2024-01-01)."
                    },
                    "observation_end": {
                        "title": "Observation End Date",
                        "type": "string",
                        "description": "End date for time series observations (ISO 8601, e.g. 2025-01-01)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
