You need the Federal Funds Effective Rate inside your application, with reliable timestamps and APIs you can wire into dashboards, loan models, or risk systems. By the end of this article, you’ll be able to fetch, cache, and analyze the Fed Funds (FED_FUNDS) rate using the Interest Rates API, compute spreads and monthly payments from returned values, and integrate seven purpose-built endpoints for production workflows.
What the Fed Funds (FED_FUNDS) rate represents and how it’s expressed
FED_FUNDS is the effective overnight federal funds rate: the volume-weighted rate at which U.S. depository institutions lend reserve balances to each other overnight. It is a key policy-sensitive benchmark that influences short-term funding costs, floating-rate loans, and discounting assumptions across USD markets.
In the Interest Rates API, FED_FUNDS is returned as a numeric percentage (per annum). For example, a JSON value of 3.75 means 3.75% annualized. Dates are ISO 8601 (YYYY-MM-DD). When you query the latest or historical endpoints, use the “rates” map to read the numeric level and the “dates” map (where present) for the effective date of that observation. Currency is supplied in the “currencies” map and will be “USD” for FED_FUNDS.
Key use cases include:
- Interest rate dashboards and treasuries monitoring policy-sensitive benchmarks.
- Loan pricing engines using FED_FUNDS plus a spread to set floating rates.
- Macro research, scenario analysis, and time-series modeling.
- Risk systems assessing exposure to short-term rate changes and volatility.
All examples below use GET requests against https://interestratesapi.com/api/v1/ with api_key as a query parameter. To begin, visit interestratesapi.com or Get started with Interest Rates API. For SDKs and tools, see the Interest Rates API MCP.
Conventions that matter for implementation
Units: All “rates” values are percentage levels (e.g., 3.75 represents 3.75%). When converting to decimals for calculations, divide by 100.
Effective date handling: The “dates” map in latest responses tells you the observation date per symbol. In historical and timeseries responses, keys in the rates map are ISO dates to use in downstream processing and caching.
Frequency and business days: The Symbols catalogue includes a “frequency” field. For FED_FUNDS, the API exposes daily observations. Data is typically populated on business days; holidays and weekends will not have entries. When you request a date with no data, use the API’s documented behavior (e.g., the historical endpoint uses the last available day within that month for monthly symbols; for daily series, request an available business date).
Caching: Cache by symbol and effective date. When aggregating, prefer timeseries for bulk retrieval and use Last-Available logic in your app to handle non-business days. Respect rate limit headers when present.
Quick start: Fetch the latest FED_FUNDS
The following official sample shows how to fetch the latest value for FED_FUNDS. Authentication uses the api_key query parameter. All requests are GET.
cURL
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_FUNDS"JSON response (official sample)
{
"success": true,
"date": "2026-09-01",
"base": "USD",
"rates": {
"FED_FUNDS": 3.75
},
"dates": {
"FED_FUNDS": "2026-09-01"
},
"currencies": {
"FED_FUNDS": "USD"
},
"base_filter_note": null
}How to read it:
- rates.FED_FUNDS = 3.75 means the effective rate is 3.75% p.a.
- dates.FED_FUNDS is the effective date of the observation.
- currencies.FED_FUNDS confirms currency as USD.
Use this value directly in analytics or convert to a decimal rate (0.0375) for calculations like spreads and monthly payments.
Endpoint 1 — Catalogue of available rate symbols
Use this endpoint to verify FED_FUNDS is available and inspect its metadata.
cURL
Python (requests)
import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="central_bank", base="USD", api_key="YOUR_API_KEY")
)
catalog = resp.json()
fed = next((s for s in catalog.get("symbols", []) if s["symbol"] == "FED_FUNDS"), None)
print(fed)JavaScript (fetch)
const url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const fed = (data.symbols || []).find(s => s.symbol === "FED_FUNDS");
console.log(fed);PHP
<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$fed = null;
if (isset($data["symbols"])) {
foreach ($data["symbols"] as $s) {
if ($s["symbol"] === "FED_FUNDS") { $fed = $s; break; }
}
}
print_r($fed);
?>JSON response example
Key fields:
- symbol: Use this code (FED_FUNDS) in all other endpoints.
- frequency: Daily series for programmatic scheduling and caching.
Endpoint 2 — Latest value
Fetch the most recent FED_FUNDS reading to power dashboards and intraday risk updates.
cURL
Python (requests)
import requests
r = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="FED_FUNDS", api_key="YOUR_API_KEY")
)
data = r.json()
rate = data["rates"]["FED_FUNDS"]
date = data.get("dates", {}).get("FED_FUNDS", data.get("date"))
print(rate, date)JavaScript (fetch)
const response = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS&api_key=YOUR_API_KEY"
);
const data = await response.json();
const rate = data.rates.FED_FUNDS;
const effDate = (data.dates && data.dates.FED_FUNDS) || data.date;
console.log(rate, effDate);PHP
<?php
$query = http_build_query(["symbols" => "FED_FUNDS", "api_key" => "YOUR_API_KEY"]);
$json = file_get_contents("https://interestratesapi.com/api/v1/latest?$query");
$data = json_decode($json, true);
$rate = $data["rates"]["FED_FUNDS"];
$date = isset($data["dates"]["FED_FUNDS"]) ? $data["dates"]["FED_FUNDS"] : $data["date"];
echo $rate . " on " . $date;
?>JSON response example
Field notes:
- rates is a map of symbol to latest level.
- dates provides effective dates per symbol (prefer this over the top-level date when present).
- currencies confirms the currency for each symbol.
Endpoint 3 — Historical value on a specific date
Use this to load a point-in-time value for a business date. For monthly symbols, the API notes it will use the last available day within that month; FED_FUNDS is exposed as a daily series.
cURL
Python (requests)
import requests
params = {"date": "2025-06-15", "symbols": "FED_FUNDS", "api_key": "YOUR_API_KEY"}
data = requests.get("https://interestratesapi.com/api/v1/historical", params=params).json()
value = data["rates"]["FED_FUNDS"]
print("FED_FUNDS on", data["date"], "=", value)JavaScript (fetch)
const url = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
console.log("FED_FUNDS on", data.date, "=", data.rates.FED_FUNDS);PHP
<?php
$params = http_build_query([
"date" => "2025-06-15",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$json = file_get_contents("https://interestratesapi.com/api/v1/historical?$params");
$data = json_decode($json, true);
echo "FED_FUNDS on " . $data["date"] . " = " . $data["rates"]["FED_FUNDS"];
?>JSON response example
Endpoint 4 — Time series between two dates
Fetch a continuous series to power charts, regressions, or rolling analytics. Use the rates map to iterate by date, and the frequencies map to confirm sampling.
cURL
Python (requests)
import requests
p = {"start": "2025-10-08", "end": "2026-10-08", "symbols": "FED_FUNDS", "api_key": "YOUR_API_KEY"}
ts = requests.get("https://interestratesapi.com/api/v1/timeseries", params=p).json()
series = ts["rates"]["FED_FUNDS"] # dict of date -> value
# Example: compute a simple average over the returned dates
values = list(series.values())
avg = sum(values) / len(values)
print("Observations:", len(values), "Average:", avg)JavaScript (fetch)
const url = "https://interestratesapi.com/api/v1/timeseries?start=2025-10-08&end=2026-10-08&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const points = Object.entries(data.rates.FED_FUNDS);
console.log("Rows:", points.length, "First:", points[0]);PHP
<?php
$params = http_build_query([
"start" => "2025-10-08",
"end" => "2026-10-08",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$json = file_get_contents("https://interestratesapi.com/api/v1/timeseries?$params");
$data = json_decode($json, true);
$series = $data["rates"]["FED_FUNDS"];
echo "First key: " . array_key_first($series) . " Value: " . reset($series);
?>JSON response example
Field notes:
- rates.FED_FUNDS is a date-indexed map of values.
- frequencies informs resampling strategies or expected gaps.
Endpoint 5 — Fluctuation (change statistics over a range)
Use this to compute absolute and percentage changes, as well as highs and lows for your chosen window.
cURL
Python (requests)
import requests
params = {"start": "2025-10-08", "end": "2026-10-08", "symbols": "FED_FUNDS", "api_key": "YOUR_API_KEY"}
fluc = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params).json()
stats = fluc["rates"]["FED_FUNDS"]
print(stats["start_value"], stats["end_value"], stats["change"], stats["change_pct"])JavaScript (fetch)
const u = "https://interestratesapi.com/api/v1/fluctuation?start=2025-10-08&end=2026-10-08&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const r = await fetch(u);
const d = await r.json();
console.log(d.rates.FED_FUNDS);PHP
<?php
$p = http_build_query([
"start" => "2025-10-08",
"end" => "2026-10-08",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$j = file_get_contents("https://interestratesapi.com/api/v1/fluctuation?$p");
$d = json_decode($j, true);
print_r($d["rates"]["FED_FUNDS"]);
?>JSON response example
Field notes:
- change and change_pct quantify movement over the specified window.
- high and low support basic risk scanning and chart annotations.
Endpoint 6 — OHLC (candlestick) data
Generate monthly, weekly, or quarterly OHLC for charts or technical summary tables. The API computes OHLC from daily data on the fly.
cURL
Python (requests)
import requests
params = {
"symbols": "FED_FUNDS",
"period": "monthly",
"start": "2025-10-08",
"end": "2026-10-08",
"api_key": "YOUR_API_KEY"
}
ohlc = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params).json()
rows = ohlc["rates"]["FED_FUNDS"]
for row in rows:
print(row["period"], row["open"], row["high"], row["low"], row["close"], row["data_points"])JavaScript (fetch)
const u = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS&period=monthly&start=2025-10-08&end=2026-10-08&api_key=YOUR_API_KEY";
const res = await fetch(u);
const ohlc = await res.json();
console.log(ohlc.rates.FED_FUNDS);PHP
<?php
$q = http_build_query([
"symbols" => "FED_FUNDS",
"period" => "monthly",
"start" => "2025-10-08",
"end" => "2026-10-08",
"api_key" => "YOUR_API_KEY"
]);
$json = file_get_contents("https://interestratesapi.com/api/v1/ohlc?$q");
$data = json_decode($json, true);
print_r($data["rates"]["FED_FUNDS"]);
?>JSON response example
Field notes:
- period: A YYYY-MM string for monthly aggregation.
- data_points: Count of daily observations used in the aggregation.
Endpoint 7 — Convert (loan interest cost comparison)
Compare total simple interest costs for a notional amount using the latest rate from two symbols. This is useful for quick spread-based decisioning in loan workflows.
cURL
Python (requests)
import requests
p = {
"from": "FED_FUNDS",
"to": "ECB_MRO",
"amount": 100000,
"term_months": 12,
"api_key": "YOUR_API_KEY"
}
res = requests.get("https://interestratesapi.com/api/v1/convert", params=p).json()
print(res["from"]["rate"], res["from"]["total_interest"])
print(res["to"]["rate"], res["to"]["total_interest"])
print("Spread:", res["difference"]["rate_spread"])JavaScript (fetch)
const p = "from=FED_FUNDS&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY";
const r = await fetch("https://interestratesapi.com/api/v1/convert?" + p);
const d = await r.json();
console.log(d.difference.rate_spread, d.difference.interest_saved);PHP
<?php
$params = http_build_query([
"from" => "FED_FUNDS",
"to" => "ECB_MRO",
"amount" => 100000,
"term_months" => 12,
"api_key" => "YOUR_API_KEY"
]);
$json = file_get_contents("https://interestratesapi.com/api/v1/convert?$params");
$data = json_decode($json, true);
echo "Spread: " . $data["difference"]["rate_spread"];
?>JSON response example
Field notes:
- rate is the latest level for each symbol.
- total_interest and total_payment are computed for a simple loan over term_months.
- difference.rate_spread is the arithmetic spread between the two latest rates.
Practical computations with FED_FUNDS
Compute a spread
If your loan is priced at “FED_FUNDS + X bps,” compute X from two known rates. Example using the latest endpoint values in your app:
# Pseudocode using a returned latest value
fed = 3.75 # percent, from rates.FED_FUNDS
loan_rate = 5.00 # percent, your product rate
spread_bps = (loan_rate - fed) * 100 # basis pointsAlways work in percent for readability, convert to decimal (divide by 100) only when applying to amounts.
Compute a monthly payment (simple interest or amortized)
For simple interest over N months, use amount * (rate_decimal) * (N/12). If your product is amortizing (e.g., equal payments), convert the annual rate to a monthly rate and use the annuity formula:
# Using a returned latest value, e.g., 3.75% - convert to monthly
annual_pct = 3.75
r = (annual_pct / 100.0) / 12.0
n = 24 # months
principal = 250000
# Amortized payment:
payment = principal * (r * (1 + r)**n) / ((1 + r)**n - 1)Do not hardcode rates. Always read from the API and handle days with no data by selecting the most recent available business date in your window.
Error handling and rate limits
Common error shapes include success=false with an error message. Notable HTTP statuses:
- 401: Missing or invalid api_key
- 403: Account without active plan
- 404: No symbols matched or no data for the requested date/range
- 422: Validation error (e.g., wrong date format)
- 429: Request quota exhausted (observe Retry-After, X-RateLimit-* headers)
Implement retries with backoff on 429 and persist a local cache keyed by (symbol, date). This reduces latency and protects quota.
End-to-end workflow for FED_FUNDS integrations
- Discovery: Use /symbols to confirm FED_FUNDS metadata, frequency, and currency.
- Point-in-time read: Use /historical to seed your database for specific dates.
- Bulk ingest: Use /timeseries for ranges to build charts and models.
- Monitoring: Use /latest for dashboards and alerting.
- Analytics: Use /fluctuation for change stats and /ohlc for visual summaries.
- Loan comparisons: Use /convert for quick interest cost benchmarks between FED_FUNDS and another symbol.
Explore more tools at interestratesapi.com, read SDK notes in the MCP, and Register for an API key to start building.
FAQ
Q: What timezone are dates in?
A: Dates are ISO 8601 (YYYY-MM-DD). The API returns dates without times; treat them as effective dates for the observation. If you aggregate intraday, use the “dates” map when present to anchor each value.
Q: How should I handle weekends and holidays?
A: The series is populated on business days. For missing dates, request the nearest prior business day or use /historical and /timeseries to pull available observations and fill forward in your application logic.
Q: Are values percentages or decimals?
A: Percentages. For example, 3.75 represents 3.75% per annum. Divide by 100 to obtain a decimal rate when doing arithmetic.
Q: How do I compute a monthly payment from FED_FUNDS?
A: Convert the annual percent to a monthly decimal rate r = (annual_pct/100)/12 and then apply either simple interest (amount * r * months) or the standard amortization formula for equal payments.
Q: How do I check that FED_FUNDS is a daily series?
A: Call /symbols and inspect the “frequency” field for FED_FUNDS. Use /timeseries to validate expected date coverage in your chosen window.
Build your FED_FUNDS integration now: Register for Interest Rates API, browse tools in the Interest Rates API MCP, and Get started with Interest Rates API. Once you have YOUR_API_KEY, plug it into the endpoints above and ship your dashboard, pricing engine, or research pipeline.
