You need the Federal Funds Effective Rate in your software with reliable dates, formats, and performance. By the end of this article, you will query FED_FUNDS_DAILY from the Interest Rates API, interpret the responses (rates, dates, currencies), work with historical time series, compute changes and spreads, and embed the data into dashboards, pricing, or risk workflows with production‑ready cURL, Python, JavaScript, and PHP examples.
What FED_FUNDS_DAILY Represents and How It’s Expressed
FED_FUNDS_DAILY is the Federal Funds Effective Rate, delivered as a daily series in USD. It captures the effective overnight rate at which depository institutions trade balances at the Federal Reserve. This benchmark is core to U.S. money markets and is often the reference point for short-term USD funding costs, floating-rate loan indices, and monetary policy transmission.
In the API, the rate is returned as a percentage level (for example, 3.88 means 3.88% per annum). There are no time-of-day timestamps—responses provide effective dates as YYYY-MM-DD. The “dates” object in responses tells you the exact effective date of the latest value for each symbol you requested, which you should use for chart labels, valuation dates, or backtesting alignment.
Publication cadence is daily (business days). On weekends and U.S. market holidays, you should expect no new observation. When backfilling or building time series, handle missing calendar days by forward-filling or leaving gaps, depending on your methodology.
Base URL, Authentication, and Request Method
- Base URL: https://interestratesapi.com/api/v1/
- Authentication: Append api_key as a query parameter to every request (for example, ?api_key=YOUR_API_KEY). Do not use headers for auth.
- HTTP method: All endpoints are GET.
Explore the platform at interestratesapi.com, and when you are ready to call the API, use the registration link below.
Get the Latest FED_FUNDS_DAILY Value
Use the latest endpoint to fetch the most recent effective rate. Copy and run the official cURL and parse the official JSON below.
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_FUNDS_DAILY"
{
"success": true,
"date": "2026-11-03",
"base": "USD",
"rates": {
"FED_FUNDS_DAILY": 3.88
},
"dates": {
"FED_FUNDS_DAILY": "2026-11-03"
},
"currencies": {
"FED_FUNDS_DAILY": "USD"
},
"base_filter_note": null
}
Key fields you will use:
- rates: Map from symbol to the latest percentage level (e.g., {"FED_FUNDS_DAILY": 3.88}).
- dates: Effective date per symbol, which you should display in UI and store alongside the value.
- currencies: The currency for each symbol (USD here).
Latest: Python example
import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="FED_FUNDS_DAILY", api_key="YOUR_API_KEY")
)
data = resp.json()
ff_effective = data["rates"]["FED_FUNDS_DAILY"]
ff_date = data["dates"]["FED_FUNDS_DAILY"]
ff_ccy = data["currencies"]["FED_FUNDS_DAILY"]
print(f"Fed Funds Effective: {ff_effective}% on {ff_date} ({ff_ccy})")
Latest: JavaScript example
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 effDate = data.dates.FED_FUNDS_DAILY;
const ccy = data.currencies.FED_FUNDS_DAILY;
console.log(`Fed Funds Effective: ${rate}% on ${effDate} (${ccy})`);
Latest: PHP example
<?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"];
$ccy = $data["currencies"]["FED_FUNDS_DAILY"];
echo "Fed Funds Effective: {$rate}% on {$date} ({$ccy})";
?>
Catalogue of Symbols (Filter to Central Bank, USD)
Although our focus is FED_FUNDS_DAILY, you can discover symbols programmatically. Filter by category and base currency as needed.
The symbols response includes the frequency field. For FED_FUNDS_DAILY, treat the frequency as daily and plan your ingestion accordingly.
Symbols: Python example
import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="central_bank", base="USD", api_key="YOUR_API_KEY")
)
symbols = resp.json()["symbols"]
print([s["symbol"] for s in symbols])
Symbols: JavaScript example
const res = await fetch(
'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY'
);
const data = await res.json();
console.log(data.symbols.map(s => s.symbol));
Symbols: PHP example
<?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);
$symbols = array_map(fn($s) => $s["symbol"], $data["symbols"]);
print_r($symbols);
?>
Historical Value on a Specific Date
Use the historical endpoint to retrieve the FED_FUNDS_DAILY value for a given date (YYYY-MM-DD). This is essential for valuations, backtests, and compliance reporting tied to a certain day.
For date alignment, note that for monthly symbols the API returns the last day with data in that month. FED_FUNDS_DAILY is daily, so it returns the observation for that calendar date if available; otherwise, check for business-day gaps.
Historical: Python example
import requests
params = dict(date="2025-06-15", symbols="FED_FUNDS_DAILY", api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/historical", params=params)
data = r.json()
print(data["rates"]["FED_FUNDS_DAILY"], data["date"])
Historical: JavaScript example
const resp = await fetch(
'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY'
);
const data = await resp.json();
console.log(data.rates.FED_FUNDS_DAILY, data.date);
Historical: PHP example
<?php
$url = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
echo $data["rates"]["FED_FUNDS_DAILY"] . " on " . $data["date"];
?>
Daily Time Series Between Two Dates
The timeseries endpoint returns daily values over a specified window for the symbol you pass. This is ideal for charts, volatility analytics, and rolling averages.
Use rates.FED_FUNDS_DAILY as a date-to-value map. The frequencies object confirms granularity for each symbol.
Time Series: Python example
import requests
params = dict(
start="2025-11-06",
end="2026-11-06",
symbols="FED_FUNDS_DAILY",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/timeseries", params=params)
ts = r.json()["rates"]["FED_FUNDS_DAILY"]
# Example: compute a simple average over available keys
values = list(ts.values())
avg = sum(values) / len(values)
print(f"Observations: {len(values)}, Average: {avg}%")
Time Series: JavaScript example
const res = await fetch(
'https://interestratesapi.com/api/v1/timeseries?start=2025-11-06&end=2026-11-06&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY'
);
const data = await res.json();
const series = data.rates.FED_FUNDS_DAILY;
const dates = Object.keys(series).sort();
console.log(`First date: ${dates[0]}, value: ${series[dates[0]]}`);
Time Series: PHP example
<?php
$url = "https://interestratesapi.com/api/v1/timeseries?start=2025-11-06&end=2026-11-06&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$series = $data["rates"]["FED_FUNDS_DAILY"];
ksort($series);
reset($series);
$firstDate = key($series);
$firstVal = current($series);
echo "First observation: {$firstDate} = {$firstVal}%";
?>
Fluctuation: Changes, Highs, and Lows Over a Window
To summarize changes over a period, the fluctuation endpoint computes start and end values, absolute and percentage change, and the high/low within the window. This is convenient for performance summaries or alerting logic.
Fields you will use include change (absolute percentage points) and change_pct (percentage change relative to the start_value). If start_value equals 0, change_pct will be null.
Fluctuation: Python example
import requests
params = dict(
start="2025-11-06",
end="2026-11-06",
symbols="FED_FUNDS_DAILY",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params)
f = r.json()["rates"]["FED_FUNDS_DAILY"]
print(f'Δ {f["change"]} pp over {f["start_date"]} → {f["end_date"]} (pct: {f["change_pct"]}%)')
Fluctuation: JavaScript example
const res = await fetch(
'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-06&end=2026-11-06&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY'
);
const { rates } = await res.json();
const stats = rates.FED_FUNDS_DAILY;
console.log(`High=${stats.high}, Low=${stats.low}, Change=${stats.change} pp`);
Fluctuation: PHP example
<?php
$url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-11-06&end=2026-11-06&symbols=FED_FUNDS_DAILY&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$fx = $data["rates"]["FED_FUNDS_DAILY"];
echo "Change: {$fx["change"]} pp; High: {$fx["high"]}; Low: {$fx["low"]}";
?>
OHLC: Candlestick Aggregations from Daily Data
OHLC aggregates daily observations into weekly, monthly, or quarterly bars. Use these for charting, seasonality reviews, or analytics frameworks that expect candlesticks.
Use data_points to confirm the count of included daily observations per period. OHLC is computed on-the-fly from the underlying daily series; no separate OHLC table exists.
OHLC: Python example
import requests
params = dict(
symbols="FED_FUNDS_DAILY",
period="monthly",
start="2025-11-06",
end="2026-11-06",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params)
bars = r.json()["rates"]["FED_FUNDS_DAILY"]
for b in bars:
print(b["period"], b["open"], b["high"], b["low"], b["close"], b["data_points"])
OHLC: JavaScript example
const res = await fetch(
'https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS_DAILY&period=monthly&start=2025-11-06&end=2026-11-06&api_key=YOUR_API_KEY'
);
const data = await res.json();
const bars = data.rates.FED_FUNDS_DAILY;
console.log(bars.map(b => `${b.period}: O=${b.open} H=${b.high} L=${b.low} C=${b.close}`));
OHLC: PHP example
<?php
$url = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS_DAILY&period=monthly&start=2025-11-06&end=2026-11-06&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$bars = $data["rates"]["FED_FUNDS_DAILY"];
foreach ($bars as $b) {
echo "{$b["period"]}: O={$b["open"]}, H={$b["high"]}, L={$b["low"]}, C={$b["close"]} (n={$b["data_points"]})\n";
}
?>
Convert: Compare Loan Interest Costs Using FED_FUNDS_DAILY
Use the convert endpoint to compare simple loan interest cost at the latest FED_FUNDS_DAILY versus another benchmark. This is useful for pricing tools and quick spread analytics based on latest levels.
difference.rate_spread is the absolute percentage point spread between the two latest rates. The endpoint returns simple loan cost comparisons based on those latest levels and the specified term and amount.
Convert: Python example
import requests
params = dict(from="FED_FUNDS_DAILY", to="ECB_MRO", amount=100000, term_months=12, api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/convert", params=params)
data = r.json()
spread = data["difference"]["rate_spread"]
print(f"Rate spread: {spread} pp; interest saved: {data['difference']['interest_saved']}")
Convert: JavaScript example
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_API_KEY'
);
const data = await res.json();
console.log(`From rate: ${data.from.rate}% vs To rate: ${data.to.rate}% (spread ${data.difference.rate_spread} pp)`);
Convert: PHP example
<?php
$url = "https://interestratesapi.com/api/v1/convert?from=FED_FUNDS_DAILY&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
echo "Spread: {$data["difference"]["rate_spread"]} pp; Total (from): {$data["from"]["total_payment"]}";
?>
Practical Implementation Details
Units and reading values
- All rates for FED_FUNDS_DAILY are percentages (for example, 3.88 means 3.88% per annum).
- Use the dates map for symbol-specific effective dates instead of relying solely on the top-level date field.
- Use currencies.FED_FUNDS_DAILY to confirm the currency (USD).
Business days and missing dates
- FED_FUNDS_DAILY is daily but does not produce new values on weekends or U.S. holidays.
- When you request a range, you may observe gaps for non-business days; apply forward-fill or leave gaps according to your modeling standards.
Caching strategies
- Cache latest responses for the symbol and effective date you received; you typically do not need to re-fetch until a new effective date is published.
- For historical and timeseries, cache responses keyed by (symbol, start, end) to avoid repeat downloads in dashboards and batch jobs.
- Observe the X-RateLimit-* headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) and handle 429 responses with the Retry-After header.
Computing a spread
To compute a spread between FED_FUNDS_DAILY and another rate from a latest response, subtract the second rate from the first. For example, if r1 = rates["FED_FUNDS_DAILY"] and r2 = rates["ECB_MRO"], then spread_pp = r1 - r2 (in percentage points). For end-user clarity, display to two decimals and note the effective dates of both inputs (from the dates map) in case they differ.
Monthly payment or interest cost
To approximate a simple monthly interest amount from the returned annual percentage r and principal A over m months (interest-only approximation), monthly_interest = A × (r / 100) / 12. Multiply by m for a total simple interest comparison. If you need amortized payments, plug r/12 as the periodic rate into your amortization formula. The /convert endpoint provides a direct comparison using the latest rates to estimate total interest and total payment for simple loans when you need a quick benchmark-to-benchmark comparison.
Error handling
- 401: Missing or invalid api_key; verify you included ?api_key=YOUR_API_KEY.
- 403: Account not active.
- 404: No symbols matched or no data for the date/range (may include details about available ranges). Fall back to the nearest business day if your workflow allows.
- 422: Validation error (for example, incorrect date format).
- 429: Quota exhausted. Inspect Retry-After and X-RateLimit-* for backoff.
Real-World Use Cases for FED_FUNDS_DAILY
- Interest rate dashboards: Show today’s Fed Funds Effective alongside intraday or end-of-day market indicators, with a historical chart from /timeseries.
- Loan pricing and benchmarking: Compute a spread over FED_FUNDS_DAILY to adjust lender margins or evaluate floating-rate resets.
- Macro research and risk: Use /fluctuation and /ohlc to summarize monthly changes, drawdowns, and distribution of daily observations for scenario analysis.
- Treasury and cash management: Track daily shifts to inform short-term investment policies and overnight liquidity pricing.
Build and iterate on top of the API docs at MCP and explore more endpoints on interestratesapi.com.
Putting It All Together: A Minimal Integration Plan
- Call /latest for FED_FUNDS_DAILY at app startup and cache the tuple (value, effective date, currency).
- For charts, fetch /timeseries over your desired window; store the date-to-value map. Optionally compute rolling stats client-side.
- For change summaries, call /fluctuation on the same window and display the change, percent change, and high/low.
- For candlestick views, call /ohlc with period=monthly to populate OHLC charts and confirm sample size using data_points.
- For pricing comparisons, call /convert with a second benchmark and display the returned total_interest and rate_spread.
FAQ
Q: Are FED_FUNDS_DAILY values annualized percentages?
A: Yes. The rates array returns percentage levels (e.g., 3.88 means 3.88% per annum). Use the dates map to understand the effective date.
Q: What happens on weekends and holidays?
A: No new daily observation is published. Your time series will reflect business-day frequency; gaps are expected across non-business days.
Q: Can I query multiple symbols alongside FED_FUNDS_DAILY?
A: Yes. /latest, /historical, /timeseries, and /fluctuation accept comma-separated symbols. Inspect the dates map per symbol since effective dates may differ.
Q: How should I cache the data?
A: Cache latest responses keyed by symbol and effective date; for time series use (symbol, start, end). Respect 429 responses and use Retry-After plus X-RateLimit-* headers to schedule retries.
Q: How do I compute a simple spread?
A: Subtract the comparator rate from FED_FUNDS_DAILY: spread_pp = r_fedfunds - r_other. If you need an instant loan-cost comparison, use /convert.
Ready to integrate FED_FUNDS_DAILY into your app? Get your API key and start building: Register. For additional technical details and endpoint parameters, visit the MCP page. You can always explore more at interestratesapi.com.