Fed Funds Daily (FED_FUNDS_DAILY) Rate History

Fed Funds Daily (FED_FUNDS_DAILY) Rate History

You need to load the Federal Funds Effective Rate into code—fast—and keep it accurate across latest snapshots, point-in-time queries, and multi-month analyses. By the end of this guide, you will query FED_FUNDS_DAILY from interestratesapi.com using all seven endpoints (latest, symbols, historical, timeseries, fluctuation, OHLC, and convert), interpret the JSON fields correctly, and implement caching and calculations like spreads and loan payments without guesswork.

What the FED_FUNDS_DAILY rate represents

FED_FUNDS_DAILY is the Federal Funds Effective Rate at a daily frequency for USD. It represents the rate at which depository institutions lend balances at the Federal Reserve to other depository institutions overnight. It is a foundational short-term benchmark used across money markets, floating-rate loan indices, and macroeconomic monitoring.

Illustration: Fed Funds Daily (FED_FUNDS_DAILY) Rate History

In the API, rates are expressed in percent (for example 3.88 means 3.88% per annum). Dates returned alongside rates (for example under the “dates” map) indicate the effective date of the observation. When building precision-sensitive analytics, treat these dates as the reference for time alignment, not your local ingestion timestamp.

Data availability generally follows business days. Weekends and US federal holidays typically do not have new observations, and timeseries responses will only include days with an observation. For “latest” queries on non-business days, the API returns the most recent available business date with a datapoint.

Everything in this article uses only the documented endpoints from interestratesapi.com. All requests are HTTP GET and authenticated with the api_key query parameter.

Quickstart: Latest FED_FUNDS_DAILY in one call

The fastest way to pull the current effective rate is the latest endpoint. Use the official sample below exactly as shown to validate your connectivity and parsing. Authentication is via the api_key query parameter—no headers.

Official cURL

curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_FUNDS_DAILY"

Official JSON (copy verbatim)

{
    "success": true,
    "date": "2026-10-16",
    "base": "USD",
    "rates": {
        "FED_FUNDS_DAILY": 3.88
    },
    "dates": {
        "FED_FUNDS_DAILY": "2026-10-16"
    },
    "currencies": {
        "FED_FUNDS_DAILY": "USD"
    },
    "base_filter_note": null
}

How to read this:

  • rates map: key is the symbol (“FED_FUNDS_DAILY”), value is the latest rate in percent (3.88 means 3.88%).
  • dates map: the effective date of the value for that symbol.
  • currencies map: the base currency for the rate (USD).
  • date (top-level): the server’s “as of” date for the overall payload; use the dates map for per-symbol effective dates when you query multiple symbols.

Python: Parse the latest rate

import requests

url = "https://interestratesapi.com/api/v1/latest"
params = {"symbols": "FED_FUNDS_DAILY", "api_key": "YOUR_API_KEY"}
resp = requests.get(url, params=params)
data = resp.json()

rate = data["rates"]["FED_FUNDS_DAILY"] # percent, e.g., 3.88
effective_date = data["dates"]["FED_FUNDS_DAILY"] # e.g., "2026-10-16"

print(rate, effective_date)

JavaScript: Fetch the latest

const response = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY"
);
const data = await response.json();
const rate = data.rates["FED_FUNDS_DAILY"];
const date = data.dates["FED_FUNDS_DAILY"];
console.log(rate, date);

PHP: Fetch the latest

<?php
$url = "https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);

$rate = $data["rates"]["FED_FUNDS_DAILY"];
$date = $data["dates"]["FED_FUNDS_DAILY"];
echo $rate . " on " . $date;
?

Get an API key and start building now: Register. For interface capabilities and model context, see MCP.

Endpoint-by-endpoint: FED_FUNDS_DAILY integration

1) Symbols: discoverability and metadata

Use /symbols to programmatically discover available identifiers, filterable by category, base currency, or provider. This is helpful for build-time assertions or health checks in CI.

cURL

JSON

Note: When you query discoverability, you can filter for USD and central_bank, then select FED_FUNDS_DAILY as the daily effective rate symbol used throughout this article.

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params={"category": "central_bank", "base": "USD", "api_key": "YOUR_KEY"}
)
symbols = resp.json()["symbols"]

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY"
);
const meta = await res.json();

PHP

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY";
$data = json_decode(file_get_contents($url), true);
$symbols = $data["symbols"];
?

2) Latest: single-snapshot integrations

Use /latest to populate dashboards, monitors, and event-driven triggers. Prefer the per-symbol dates map to align values when mixing frequencies.

cURL

JSON

Important fields:

  • rates: numeric percent values.
  • dates: per-symbol effective date strings in Y-m-d.
  • currencies: symbol-to-currency mapping.

Python

import requests
response = requests.get(
'https://interestratesapi.com/api/v1/latest',
params=dict(symbols='FED_FUNDS_DAILY,ECB_MRO', api_key='YOUR_KEY')
)
data = response.json()

JavaScript

const response = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS_DAILY&api_key=YOUR_KEY'
);
const data = await response.json();

PHP

<?php
$q = http_build_query([
"symbols" => "FED_FUNDS_DAILY,ECB_MRO",
"api_key" => "YOUR_KEY"
]);
$url = "https://interestratesapi.com/api/v1/latest?$q";
$data = json_decode(file_get_contents($url), true);
$rate = $data["rates"]["FED_FUNDS_DAILY"];
$date = $data["dates"]["FED_FUNDS_DAILY"];
?

3) Historical: point-in-time lookup

Use /historical to retrieve the rate on a specific effective date. If there is no observation on that day for a monthly symbol, the API uses the last day with data within that month (not applicable to this daily symbol, but useful to know when mixing rates).

cURL

JSON

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/historical",
params={"date": "2025-06-15", "symbols": "FED_FUNDS_DAILY", "api_key": "YOUR_KEY"}
)
pt = resp.json()

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_FUNDS_DAILY&api_key=YOUR_KEY"
);
const hist = await res.json();

PHP

<?php
$params = http_build_query([
"date" => "2025-06-15",
"symbols" => "FED_FUNDS_DAILY",
"api_key" => "YOUR_KEY"
]);
$hist = json_decode(file_get_contents("https://interestratesapi.com/api/v1/historical?$params"), true);
$val = $hist["rates"]["FED_FUNDS_DAILY"];
?

4) Timeseries: full-range analysis

Use /timeseries to retrieve daily observations between start and end dates. Returned dates include only those with observations.

cURL

JSON

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/timeseries",
params={"start": "2025-10-22", "end": "2026-10-22", "symbols": "FED_FUNDS_DAILY", "api_key": "YOUR_KEY"}
)
series = resp.json()["rates"]["FED_FUNDS_DAILY"]

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/timeseries?start=2025-10-22&end=2026-10-22&symbols=FED_FUNDS_DAILY&api_key=YOUR_KEY"
);
const ts = await res.json();
const points = ts.rates["FED_FUNDS_DAILY"];

PHP

<?php
$q = http_build_query([
"start" => "2025-10-22",
"end" => "2026-10-22",
"symbols" => "FED_FUNDS_DAILY",
"api_key" => "YOUR_KEY"
]);
$ts = json_decode(file_get_contents("https://interestratesapi.com/api/v1/timeseries?$q"), true);
$points = $ts["rates"]["FED_FUNDS_DAILY"];
?

5) Fluctuation: change and range statistics

Use /fluctuation to compute change, percent change, and high/low over a date range. This is ideal for performance summaries and alerting.

cURL

JSON

Key fields per symbol:

  • start_value / end_value: first and last observed values in the window.
  • change / change_pct: absolute and percent change from start to end (percent relative to start_value; null if start_value is 0).
  • high / low: extrema within the window.

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params={"start": "2025-10-22", "end": "2026-10-22", "symbols": "FED_FUNDS_DAILY", "api_key": "YOUR_KEY"}
)
stats = resp.json()["rates"]["FED_FUNDS_DAILY"]

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/fluctuation?start=2025-10-22&end=2026-10-22&symbols=FED_FUNDS_DAILY&api_key=YOUR_KEY"
);
const fluc = await res.json();
const s = fluc.rates["FED_FUNDS_DAILY"];

PHP

<?php
$q = http_build_query([
"start" => "2025-10-22",
"end" => "2026-10-22",
"symbols" => "FED_FUNDS_DAILY",
"api_key" => "YOUR_KEY"
]);
$fluc = json_decode(file_get_contents("https://interestratesapi.com/api/v1/fluctuation?$q"), true);
$s = $fluc["rates"]["FED_FUNDS_DAILY"];
?

6) OHLC: candlestick aggregates for charts

Use /ohlc to transform daily FED_FUNDS_DAILY observations into open-high-low-close by period (weekly, monthly, or quarterly). This is computed from daily data on the fly—no separate OHLC table is stored—so you can align charting panels with other market series.

cURL

JSON

Key fields:

  • period: the aggregation bucket label, e.g., YYYY-MM for monthly.
  • open/high/low/close: computed from daily observations in the bucket.
  • data_points: count of observations used to compute the OHLC.

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/ohlc",
params={"symbols": "FED_FUNDS_DAILY", "period": "monthly", "start": "2025-10-22", "end": "2026-10-22", "api_key": "YOUR_KEY"}
)
ohlc = resp.json()["rates"]["FED_FUNDS_DAILY"]

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS_DAILY&period=monthly&start=2025-10-22&end=2026-10-22&api_key=YOUR_KEY"
);
const o = await res.json();
const candles = o.rates["FED_FUNDS_DAILY"];

PHP

<?php
$q = http_build_query([
"symbols" => "FED_FUNDS_DAILY",
"period" => "monthly",
"start" => "2025-10-22",
"end" => "2026-10-22",
"api_key" => "YOUR_KEY"
]);
$o = json_decode(file_get_contents("https://interestratesapi.com/api/v1/ohlc?$q"), true);
$candles = $o["rates"]["FED_FUNDS_DAILY"];
?

7) Convert: loan interest cost comparison

Use /convert to compare the total interest cost for a simple loan priced off two rate symbols at their latest values. This is useful for quick scenario analysis (e.g., pricing off FED_FUNDS_DAILY vs. another policy rate). The endpoint computes totals for you.

cURL

JSON

Key fields:

  • from/to: each includes the symbol, latest rate, effective date, and computed totals.
  • difference.rate_spread: arithmetic difference in percent between the two latest rates.
  • difference.interest_saved: total interest difference over the specified term and amount.

Python

import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/convert",
params={"from": "FED_FUNDS_DAILY", "to": "ECB_MRO", "amount": 100000, "term_months": 12, "api_key": "YOUR_KEY"}
)
cmp = resp.json()

JavaScript

const res = await fetch(
"https://interestratesapi.com/api/v1/convert?from=FED_FUNDS_DAILY&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY"
);
const cmp = await res.json();

PHP

<?php
$q = http_build_query([
"from" => "FED_FUNDS_DAILY",
"to" => "ECB_MRO",
"amount" => 100000,
"term_months" => 12,
"api_key" => "YOUR_KEY"
]);
$cmp = json_decode(file_get_contents("https://interestratesapi.com/api/v1/convert?$q"), true);
$spread = $cmp["difference"]["rate_spread"];
?

How to compute spreads and payments from the API safely

Because the API returns rates in percent, arithmetic spreads are straightforward:

  • Spread = rate_A - rate_B (e.g., FED_FUNDS_DAILY minus another symbol).
  • Always source both rates and their effective dates from the same API call where possible to avoid timing mismatches.

For monthly payments on an amortizing loan using FED_FUNDS_DAILY as the pricing index, you typically add a program margin (your spread) to the benchmark and then apply a payment formula. Without inventing numbers:

  • Let r = (FED_FUNDS_DAILY + margin) / 100 / 12 (monthly decimal rate).
  • Let n = term_months, P = principal.
  • Monthly payment M = P * r / (1 - (1 + r)^(-n)).

Because FED_FUNDS_DAILY is reported as an annual percent, remember to convert to a monthly decimal for payment computations. For dashboards that only need total interest for a simple (non-amortizing) comparison, use the /convert endpoint to avoid re-implementing.

Publication cadence, caching, and operational reliability

Frequency: FED_FUNDS_DAILY is a daily series. Observations are aligned to US business days; weekends and holidays generally have no new values. Timeseries responses include only dates with observations.

Effective dates: Use the per-symbol dates map to pin calculations to the correct observation day. If you display a single banner value, display both rate and effective date to avoid confusion on non-business days.

Caching: For production dashboards, a 5–15 minute cache is a pragmatic default for /latest. For backfills and timeseries, cache results aggressively (e.g., hours to days) since historical values do not retroactively change for closed periods in most workflows. Always validate with your governance requirements.

Error handling: Handle documented API errors and rate limits cleanly:

  • 401/403: check api_key and account status.
  • 404: may indicate no data for that symbol or date; check details for available ranges.
  • 422: validation errors (date format Y-m-d, invalid symbol string).
  • 429: respect Retry-After and X-RateLimit-* headers; implement exponential backoff.

Idempotency: All endpoints are GET and therefore safe to retry under network uncertainty. Ensure your client appends api_key as a query parameter and avoids leaking keys in logs you don’t control.

Common integration patterns for FED_FUNDS_DAILY

  • Risk dashboards: Query /latest every few minutes and show the rate with its effective date. Fall back to cached values on 429 with user notice.
  • Macro research notebooks: Pull /timeseries for a study window and compute rolling averages, changes, and correlations against other symbols using the dates from the rates map.
  • Floating-rate loan pricing: Fetch /latest for FED_FUNDS_DAILY, add your program spread, and compute amortizing payments. For quick comparisons, use /convert to sanity-check implied differences.
  • Compliance and audit: Use /historical for end-of-day or end-of-month snapshots and persist both the rate and the effective date.
  • Visualization: Use /ohlc to generate candlestick charts for policy rate evolution by month or week without pre-aggregating data yourself.

Explore more symbols and documentation at interestratesapi.com. If you plan to embed model-aware behavior, review the MCP.

Field-by-field notes you’ll actually use

  • rates: a map of symbol → numeric percent.
  • dates: a map of symbol → effective date string (Y-m-d). Prefer this for alignment.
  • currencies: a map of symbol → ISO currency code (e.g., USD).
  • frequencies: appears in /timeseries to confirm per-symbol frequency (“daily”).
  • change_pct: in /fluctuation, percent change (relative to start_value) or null if start_value is 0.
  • data_points: in /ohlc, count of daily observations used for each OHLC bucket.

All dates are ISO strings; apply your app’s timezone handling consistently. The API does not paginate in the examples shown, so you can stream the entire range into your own storage or analytics layer for backtests.

Troubleshooting and best-use reminders

  • Always include api_key as a query parameter (not a header). Example: ?api_key=YOUR_API_KEY
  • Use GET for all requests. There are no POST/PUT/DELETE endpoints in this API.
  • Validate symbols against /symbols and limit to the published identifiers (e.g., FED_FUNDS_DAILY). Do not invent codes.
  • If a date has no observation, expect it to be absent from /timeseries. Do not assume market calendar continuity.
  • Normalize percentages to decimals before calculations: pct / 100 for math, then divide by 12 for monthly rates where appropriate.

When embedding this data into production systems, log the full request URL (with the api_key masked) and the effective date used for any pricing event to ensure auditability.

FAQ

Q: What unit is FED_FUNDS_DAILY returned in?
A: Percent per annum. For example, 3.88 means 3.88% annualized. Convert to a decimal (0.0388) for calculations and to a monthly rate by dividing by 12 when needed.

Q: How do I align values across multiple symbols?
A: Use the dates map in /latest and per-symbol series keys in /timeseries to align by effective date. Do not assume the top-level date applies identically to all symbols if you request a mix.

Q: Why is my date missing in /timeseries?
A: Daily series include only observation dates. Weekends and holidays generally have no datapoint. Query a range that includes the previous business day, or use /historical for a specific day if you need a point-in-time lookup.

Q: How can I compute high/low or percent change quickly?
A: Use /fluctuation. It returns start_value, end_value, change, change_pct, high, and low for your window—no need to re-implement client-side.

Q: Can I get ready-to-plot aggregates?
A: Yes. Use /ohlc to compute open, high, low, close by weekly, monthly, or quarterly buckets, with data_points included for each bucket.

Ready to integrate FED_FUNDS_DAILY into your app? Register for an API key and start building against interestratesapi.com today. You can also review developer capabilities at the MCP.

Register for Interest Rates API · Interest Rates API MCP · Get started with Interest Rates API

Keywords
federal funds rate API FED_FUNDS_DAILY queries interest rates API development historical rate analysis financial data integration

Ready to get started?

Get your API key and start validating bank data in minutes.

Get API Key