FRED Economic Series Data Export

Export selected FRED economic data series as normalized, analysis-ready observation rows without supplying a FRED API key.

Choose real series IDs such as GDP, CPIAUCSL, or UNRATE, apply an optional date window, and receive one dataset row per observation with the series ID, date, numeric value, exact source URL, and retrieval timestamp.

What does this Actor do?

FRED Economic Series Data Export downloads the anonymous public CSV representation published by the Federal Reserve Bank of St. Louis.

It:

• accepts up to 100 selected FRED series IDs;
• fetches each series independently;
• applies optional start and end dates;
• converts numeric values to JSON numbers;
• represents FRED missing values as null;
• optionally excludes missing observations;
• selects oldest-first (asc, default) or newest-first (desc) within each series;
• optionally caps observations per series with maxItemsPerSeries;
• caps total output with maxItems and reports completeness in a free SUMMARY;
• preserves source and retrieval provenance;
• requires no FRED API key, account, cookies, browser, or proxy.

The default dataset contains normalized long-form rows that work well in spreadsheets, notebooks, databases, and dashboard refresh jobs.

Who is this FRED economic data exporter for?

This Actor is useful for:

• economists refreshing a defined indicator set;
• analysts preparing macroeconomic reports;
• data engineers loading time series into a warehouse;
• finance teams maintaining dashboard inputs;
• researchers creating reproducible observation extracts;
• developers who want FRED CSV data through the Apify API;
• automation teams scheduling recurring snapshots.

Use it when you already know the FRED IDs you need. It does not search the FRED catalog or provide credentialed API-only metadata.

Why use it?

The product focuses on a narrow recurring job: refresh selected public series and normalize their observations.

Compared with handling CSV downloads manually, it provides:

• one consistent JSON record shape across series;
• built-in date-window validation;
• deduplication of repeated input IDs;
• a total output safety limit;
• bounded transient retries;
• Apify scheduling, webhooks, integrations, datasets, and API access;
• explicit provenance on every row.

Each series uses its own CSV request. That avoids the ZIP response generated by FRED's multi-series download and makes partial pipeline diagnosis straightforward.

What data is extracted?

Field	Type	Meaning
seriesId	string	Uppercase FRED series identifier
observationDate	date string	Observation date supplied by FRED
value	number or null	Numeric value, or null for a missing FRED observation
sourceUrl	URL	Exact CSV URL, including date filters
retrievedAt	ISO timestamp	Time the source response was retrieved

Rows preserve selected series order, then observation-date order within each series (sortOrder: "asc" by default, or "desc" for newest first). The dataset still contains only the five observation fields above.

Getting started

1. Open the Actor input page.
2. Enter one or more known FRED series IDs.
3. Optionally set startDate and endDate.
4. Choose whether missing values should remain in the dataset.
5. Set a suitable maxItems cap.
6. Click Start.
7. Open the default dataset to preview or export JSON, CSV, Excel, XML, or RSS.

A small first run can use:

{
  "seriesIds": ["GDP"],
  "startDate": "2020-01-01",
  "maxItems": 30
}

Input parameters

seriesIds

Required array of one to 100 IDs. IDs are trimmed, normalized to uppercase, and deduplicated.

Examples:

• GDP — Gross Domestic Product;
• CPIAUCSL — Consumer Price Index for All Urban Consumers;
• UNRATE — Civilian Unemployment Rate;
• FEDFUNDS — Effective Federal Funds Rate.

startDate

Optional inclusive start date in YYYY-MM-DD format. It is sent to FRED as cosd.

endDate

Optional inclusive end date in YYYY-MM-DD format. It is sent to FRED as coed.

Both dates must be real calendar dates (for example, 2024-02-29 is valid, 2024-02-30 is not). The start date must not be later than the end date. Invalid input is rejected before start charging or source requests.

includeMissingValues

Defaults to true. Set it to false to omit rows whose CSV value is blank or ..

maxItems

Maximum total rows across every series. The allowed range is 1 to 100,000 and the default is 20 to keep first runs small.

The Actor stops before fetching another series after the cap is reached and truncates the current accepted batch at the cap. Check SUMMARY for unprocessed IDs. Platform charge limits can further reduce output.

sortOrder

"asc" (default) selects oldest observations first; "desc" selects newest first. This sorts dates within each series, not the series list.

maxItemsPerSeries

Optional integer from 1 to 100,000. Unset preserves the existing global-limit behavior. Selection applies the inclusive date window, missing-value filter, sort order, per-series cap, then remaining global cap (and platform charge allowance). Neither limit accepts zero or means unlimited.

Completeness receipt: SUMMARY

The output tab links to the default key-value store's free SUMMARY JSON record. It lists requested, processed, and unprocessed series IDs, total exported rows, options, and a series array. Each processed series reports exportedRows, sourceRowsInWindow, missingRowsFiltered, exported observedDateBounds (first/last dates or null), limitsApplied (maxItemsPerSeries, maxItems, chargeLimit), and truncated. Limit flags indicate actual omitted eligible rows, not merely equality with a cap. A global cap that prevents later requests logs a warning and lists those IDs as unprocessed, without guessing their available row counts. stoppedBy identifies why later series were skipped, or is null when all were processed. Empty date windows are successful empty exports, not failures.

SUMMARY is written on successful completion only. If a selected-series request fails, the run fails; any rows already exported remain partial data and must not be treated as a completed refresh. No summary records are added to the paid dataset.

Output example

A real GDP run produces records shaped like:

{
  "seriesId": "GDP",
  "observationDate": "2020-01-01",
  "value": 21751.238,
  "sourceUrl": "https://fred.stlouisfed.org/graph/fredgraph.csv?id=GDP&cosd=2020-01-01",
  "retrievedAt": "2026-09-13T14:06:27.587Z"
}

retrievedAt changes on every source response. FRED may revise historical observations, so a later run can legitimately return a changed value for the same series and date.

How much does it cost to export FRED observations?

Pricing is pay per event. A run has a one-time start event and an item event for each observation saved to the default dataset.

The current configuration uses a $0.001 start event and a BRONZE item rate of $0.0012. Estimate a run by adding the start price to the item rate multiplied by the number of saved observations.

For example, a 25-row run has one start charge plus 25 item charges; a 100-row run has one start charge plus 100 item charges. Higher Apify tiers use the decreasing item rates declared on the Actor pricing tab.

Your Apify plan tier determines the exact item price. No item fee applies to SUMMARY, unprocessed series, rejected rows or missing rows that are filtered out. Platform compute and included usage follow Apify's normal account rules.

Scheduling recurring macro reports

Create an Apify Task with your stable series list. For one latest available observation per indicator without maintaining dates, use:

{
  "seriesIds": ["GDP", "CPIAUCSL", "UNRATE"],
  "sortOrder": "desc",
  "maxItemsPerSeries": 1,
  "maxItems": 3,
  "includeMissingValues": false
}

These are each series' latest available observation dates, not publication or revision dates; mixed-frequency indicators usually have different dates. Missing rows are filtered before limits, so this example selects the newest nonmissing value. With includeMissingValues: true, the newest row can instead be null. Review SUMMARY before updating a dashboard. For historical refreshes, keep using a date window and ascending order.

Then:

1. schedule it daily, weekly, or monthly;
2. connect a webhook or integration;
3. export the new dataset;
4. upsert records by seriesId plus observationDate;
5. compare current values with your prior snapshot.

The Actor itself does not maintain historical diffs or send alerts. Apify schedules and downstream tools provide that workflow.

Spreadsheet and data-pipeline integration

The default dataset can be downloaded in CSV or Excel format from Apify Console.

For a warehouse load:

• treat seriesId and observationDate as the natural observation key;
• store retrievedAt as the extraction timestamp;
• retain sourceUrl for lineage;
• allow value to be nullable;
• choose an upsert or append strategy based on whether revisions matter.

For Google Sheets, use the Apify integration or retrieve dataset items after the run succeeds.

Run through the Apify API with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fred-economic-series-data-export/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "seriesIds": ["GDP", "CPIAUCSL", "UNRATE"],
    "startDate": "2024-01-01",
    "includeMissingValues": false,
    "maxItems": 100
  }'

Keep tokens in environment variables or a secret manager rather than source code.

JavaScript API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fred-economic-series-data-export').call({
  seriesIds: ['GDP', 'CPIAUCSL', 'UNRATE'],
  startDate: '2024-01-01',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/fred-economic-series-data-export").call(
    run_input={
        "seriesIds": ["GDP", "CPIAUCSL"],
        "startDate": "2023-01-01",
        "endDate": "2024-12-31",
        "maxItems": 100,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Use with MCP and AI assistants

Add this Actor to Claude Code through Apify MCP:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fred-economic-series-data-export"

Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, VS Code, and other MCP-capable clients can use:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fred-economic-series-data-export"
    }
  }
}

Follow one run through to bounded results

The scoped URL above selects this Actor and automatically includes get-actor-run, get-dataset-items, get-key-value-store-record, and abort-actor-run; it does not expose only one tool. First use read-only tools/list on that endpoint to discover the actual tool names and argument schemas. Use only the needed Actor/run/data helpers; discovery alone does not authorize starting or aborting a run.

1. Start once when authorized. Retain the returned run ID, status, dataset ID, and key-value-store ID. These IDs are metadata, not observation rows. If using call-actor, its waitSecs is 0–45 seconds (default 30), so the initial response can still be pending. Set the client request timeout above the chosen server wait plus transport margin, within your total deadline.
2. Follow that same run. For a nonterminal response, poll get-actor-run with the retained ID using bounded backoff, for example 2, 4, 8 seconds then at most 10 seconds between checks, with a 120-second total deadline. On client timeout, recover/check the known run instead of starting another; if the ID is unknown, report uncertainty rather than blindly rerun. At the deadline, stop polling and report pending with the run ID so a later request can resume. Report failed/aborted/timed-out runs honestly; any available rows are partial, not a successful full export.
3. Fetch actual rows after success. Use get-dataset-items with the returned dataset ID (defaultDatasetId in the run API). According to the discovered schema, explicitly set limit: 20, offset: 0, and needed fields, for example seriesId,observationDate,value,sourceUrl,retrievedAt. Prefer untransformed JSON and advance source offsets using pagination metadata, not transformed row counts: filtering/unwinding can change returned counts. Separately read the free SUMMARY record with get-key-value-store-record and the returned store ID to check Actor-side truncation or unprocessed series. A successful run can still be an intentionally capped export.
4. Bound model-context consumption. For example, admit at most 100 source rows and 64 KiB of serialized UTF-8 result content across all pages, whichever comes first. Count every admitted result, including SUMMARY, against the byte budget. Process pages host-side before model injection and stop at exhaustion or budget. Omit or summarize an oversized row/page with disclosure; never silently claim completeness. Report admitted row count, next source offset, and partial/truncated status if more data remains. Keep full downloads/exports in storage or downstream processing outside model context. These example page, deadline, and context budgets are consumer choices, not Actor collection limits or changes to maxItems/output fields.

A hard byte ceiling requires a client that can intercept and bound responses before model injection. If yours cannot, do not promise that guarantee or request unbounded results. tools/list transport bytes are not necessarily model-visible context. Discovery, caching, progressive loading, and prompt-cache behavior depend on the client and negotiated capabilities; no universal token savings are promised.

Example prompts:

• “Export GDP observations since 2020 with the FRED series exporter.”
• “Fetch CPIAUCSL and UNRATE for 2024 and return at most 50 rows.”
• “Run my recurring macro dashboard input and summarize the latest observations.”

Reliability and retry behavior

Each selected series receives one direct request to FRED's public CSV endpoint.

The Actor:

• uses a 30-second request timeout;
• retries transient network errors, HTTP 429, and server errors up to three times;
• uses short exponential backoff;
• does not blindly retry deterministic client errors;
• validates the response content type and expected CSV columns;
• fails the run if a selected series cannot be fetched correctly.

There is no automatic residential proxy or browser fallback.

Limits

• Series IDs must already be known; there is no catalog search.
• FRED's public CSV surface does not provide the richer metadata available through its credentialed API.
• Values are returned as published, without frequency aggregation, unit transformation, seasonal adjustment, or derived percent-change calculations.
• maxItems applies across all series, so an early long series can consume the cap.
• A FRED source outage or format change can fail a run.
• Historical values may be revised by the source.
• The Actor supports at most 100 unique IDs and 100,000 output rows per run.

Troubleshooting

“Invalid FRED series ID”

Remove spaces or URL fragments. Supply the identifier itself, for example GDP, not a FRED page URL.

No rows in my date range

Confirm that the series existed and published observations during the selected dates. Try removing the date window in a small capped run.

The run stops at maxItems

Increase the global cap, set maxItemsPerSeries to reserve room for later indicators, or split series into Tasks. Inspect SUMMARY for actual truncation and unprocessed IDs.

A value is null

FRED uses blank values or . for missing observations. Keep them for time-grid completeness or set includeMissingValues to false.

A run fails after retries

Inspect the log for the series ID and HTTP status. Retry later if FRED was unavailable; fix the ID if the error is deterministic.

Diagnostic privacy

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Only public economic observations and export receipts are saved to Actor storage; no AI model or AI provider is used. Apify datasets, KVS records, and logs follow your account's storage retention and deletion settings, not the diagnostic 30-day policy. Delete run storage in Apify Console/API when no longer needed. Diagnostic reports expire after 30 days. For help or deletion questions, open an issue on this Actor's Apify Store Issues tab; do not post credentials or private data.

Legality and responsible use

This Actor accesses an anonymous public data export. Follow FRED's terms, attribution guidance, and any restrictions that apply to individual underlying series.

Do not imply that Automation Lab or this Actor is affiliated with, endorsed by, or operated by the Federal Reserve Bank of St. Louis.

Dataset consumers remain responsible for:

• validating fitness for their analysis;
• preserving source attribution;
• handling revisions and missing values;
• complying with applicable laws, licenses, and organizational policies;
• avoiding unsupported financial or policy conclusions.

FAQ

Does it require a FRED API key?

No. It uses the public fredgraph.csv download surface.

Can it search for series?

No. Enter known IDs. This keeps the no-key contract predictable.

Can it fetch multiple series?

Yes, up to 100 IDs. Each is downloaded separately and normalized into one default dataset.

Does it transform units or frequency?

No. Values are preserved from the selected public export.

Can I schedule it?

Yes. Save the input as an Apify Task and attach a schedule.

How do I detect revisions?

Compare records across runs by seriesId and observationDate, using retrievedAt to identify each extraction.

Are missing values charged?

A null observation incurs the normal item price only when you choose to include it and it is saved. Set includeMissingValues to false to omit it.

Related Automation Lab Actors

This Actor is intentionally standalone in the current portfolio. The retired credentialed FRED scraper is not offered as a related public product, and no other Automation Lab Actor currently provides a closer supported continuation of this exact workflow.