You need a reliable way to pull the Federal Funds Effective Rate into your codebase, align it to business days, and compute downstream metrics like spreads, loan costs, and risk indicators. By the end of this article you will be able to query the FED_FUNDS symbol from the Interest Rates API as JSON, understand date semantics and frequency, cache results safely, and wire the output into payment calculators, dashboards, research notebooks, or treasury tools.
What the FED_FUNDS rate represents and how it’s used
FED_FUNDS is the Federal Funds Effective Rate, the overnight interest rate at which depository institutions lend balances at the Federal Reserve to other institutions. It is a key U.S. monetary policy benchmark that influences short-term funding costs, floating-rate loans, and expectations for future central bank decisions.
In the Interest Rates API, you request FED_FUNDS via REST endpoints using a GET method and receive rate values as decimals (percent per annum). The base currency for FED_FUNDS is USD. Typical use cases include:
- Interest rate dashboards for finance teams and lending platforms
- Loan comparison tools that reference a floating benchmark plus a lender spread
- Macro and markets research where you need consistent time series
- Risk and treasury models sensitive to overnight or short-end policy expectations
All examples below use the base URL https://interestratesapi.com/api/v1/ and authenticate with the api_key query parameter. You can explore the API and data model at https://interestratesapi.com and refer to the MCP for deeper integration notes.
How the API expresses FED_FUNDS values and dates
Rates are returned as annualized percentages in decimal form. For example, 3.88 means 3.88% per annum. The API’s responses include:
- rates: a symbol-to-value map
- dates: an optional map of symbols to effective dates
- currencies: a map of symbols to ISO currency codes
Effective dates should be used for display and caching. For symbols with monthly aggregation, historical requests use the last day with data within that month. For daily series and business-day calendars, expect non-weekend and non-holiday publication behavior. Always read the dates object when available to align downstream analytics.
Endpoint 1: Catalogue of available symbols
Use this endpoint to confirm that FED_FUNDS is available, discover its category and other metadata, or browse related symbols you might compare against in your app.
cURL
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_FUNDS"
Python (requests)
import requests
url = "https://interestratesapi.com/api/v1/symbols"
params = {
"category": "central_bank",
"base": "USD",
"api_key": "YOUR_API_KEY",
}
resp = requests.get(url, params=params)
data = resp.json()
print(data)
JavaScript (fetch)
const response = await fetch(
"https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY"
);
const data = await response.json();
console.log(data);
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);
print_r($data);
?>
Sample JSON
{
"success": true,
"date": "2026-10-01",
"base": "USD",
"rates": {
"FED_FUNDS": 3.88
},
"dates": {
"FED_FUNDS": "2026-10-01"
},
"currencies": {
"FED_FUNDS": "USD"
},
"base_filter_note": null
}
Key fields:
- symbol: use FED_FUNDS in subsequent queries
- frequency: operational cadence of observations in the API’s dataset
- currency_code: USD for FED_FUNDS
Endpoint 2: Latest value
Fetch the most recent available FED_FUNDS value and the effective date. This is the right call for real-time dashboards and pricing engines that need the current benchmark.
cURL (official sample — use as-is)
Python (requests)
import requests
resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params={"symbols": "FED_FUNDS", "api_key": "YOUR_API_KEY"}
)
data = resp.json()
rate = data["rates"]["FED_FUNDS"]
as_of = data.get("dates", {}).get("FED_FUNDS", data.get("date"))
print("FED_FUNDS", rate, "as_of", as_of)
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 asOf = (data.dates && data.dates.FED_FUNDS) || data.date;
console.log("FED_FUNDS", rate, "as_of", asOf);
PHP
<?php
$query = http_build_query([
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$url = "https://interestratesapi.com/api/v1/latest?{$query}";
$json = file_get_contents($url);
$data = json_decode($json, true);
$rate = $data["rates"]["FED_FUNDS"];
$asOf = $data["dates"]["FED_FUNDS"] ?? $data["date"];
echo "FED_FUNDS {$rate} as_of {$asOf}\n";
?>
Sample JSON (official — copy verbatim)
Reading the payload:
- rates.FED_FUNDS: the latest value, percent per annum
- dates.FED_FUNDS: effective date for that rate; use for display and cache keys
- base/currencies: asserts USD
Practical tip: Cache the response keyed by dates.FED_FUNDS to avoid reprocessing when the effective date hasn’t changed. Use conservative TTLs aligned with expected publication cadence; check the dates map to determine freshness.
Endpoint 3: Historical value on a specific date
Historical snapshots let you fetch the value that applied within a defined period. For symbols with monthly cadence, the API uses the last day with data in the target month. This is useful for end-of-month valuation, accounting, and reproducible backtests.
cURL
Python (requests)
import requests
params = {"date": "2025-06-15", "symbols": "FED_FUNDS", "api_key": "YOUR_API_KEY"}
resp = requests.get("https://interestratesapi.com/api/v1/historical", params=params)
data = resp.json()
print(data["rates"]["FED_FUNDS"], data["date"])
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(data.rates.FED_FUNDS, data.date);
PHP
<?php
$params = http_build_query([
"date" => "2025-06-15",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$url = "https://interestratesapi.com/api/v1/historical?{$params}";
$data = json_decode(file_get_contents($url), true);
echo $data["rates"]["FED_FUNDS"] . " on " . $data["date"] . PHP_EOL;
?>
Sample JSON
Note: For monthly symbols, the API will resolve the input date to the latest available observation within that month. Always persist the returned date along with the rate in your datastore.
Endpoint 4: Time series
Pull a continuous series of FED_FUNDS values between two dates. This powers charts, trend analysis, accrual models, and term structure estimates that rely on historical paths.
cURL
Python (requests)
import requests
params = {
"start": "2025-11-19",
"end": "2026-11-19",
"symbols": "FED_FUNDS",
"api_key": "YOUR_API_KEY"
}
resp = requests.get("https://interestratesapi.com/api/v1/timeseries", params=params)
data = resp.json()
series = data["rates"]["FED_FUNDS"]
for d, v in series.items():
print(d, v)
JavaScript (fetch)
const url = "https://interestratesapi.com/api/v1/timeseries?start=2025-11-19&end=2026-11-19&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const res = await fetch(url);
const data = await res.json();
const series = data.rates.FED_FUNDS;
Object.entries(series).forEach(([d, v]) => console.log(d, v));
PHP
<?php
$params = http_build_query([
"start" => "2025-11-19",
"end" => "2026-11-19",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$json = file_get_contents("https://interestratesapi.com/api/v1/timeseries?{$params}");
$data = json_decode($json, true);
foreach ($data["rates"]["FED_FUNDS"] as $date => $value) {
echo "{$date} {$value}\n";
}
?>
Sample JSON
Key fields:
- rates.FED_FUNDS: date-indexed map of values
- frequencies.FED_FUNDS: the series cadence
- start_date/end_date: normalized boundaries covered by the response
Practical tip: When plotting or aggregating, rely on the date keys provided rather than assuming continuous calendar coverage. Many finance rate series follow a business-day calendar.
Endpoint 5: Fluctuation (change statistics over a range)
Get summary stats for FED_FUNDS between two dates: change, percent change, and range. This is ideal for sparklines, alerting systems, and change reports.
cURL
Python (requests)
import requests
params = {
"start": "2025-11-19",
"end": "2026-11-19",
"symbols": "FED_FUNDS",
"api_key": "YOUR_API_KEY"
}
resp = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params)
stats = resp.json()["rates"]["FED_FUNDS"]
print(stats)
JavaScript (fetch)
const res = await fetch(
"https://interestratesapi.com/api/v1/fluctuation?start=2025-11-19&end=2026-11-19&symbols=FED_FUNDS&api_key=YOUR_API_KEY"
);
const data = await res.json();
console.log(data.rates.FED_FUNDS);
PHP
<?php
$params = http_build_query([
"start" => "2025-11-19",
"end" => "2026-11-19",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
$url = "https://interestratesapi.com/api/v1/fluctuation?{$params}";
$data = json_decode(file_get_contents($url), true);
print_r($data["rates"]["FED_FUNDS"]);
?>
Sample JSON
Field notes:
- change: end_value − start_value
- change_pct: 100 × change / start_value (null if start_value = 0)
- high/low: extrema in the range
Endpoint 6: OHLC (open-high-low-close) aggregation
Use OHLC to aggregate daily observations into business-friendly periods such as monthly. This is useful when you want a single monthly open/close or the intramonth high/low for dashboards and reports.
cURL
Python (requests)
import requests
params = {
"symbols": "FED_FUNDS",
"period": "monthly",
"start": "2025-11-19",
"end": "2026-11-19",
"api_key": "YOUR_API_KEY"
}
resp = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params)
ohlc = resp.json()["rates"]["FED_FUNDS"]
print(ohlc)
JavaScript (fetch)
const res = await fetch(
"https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS&period=monthly&start=2025-11-19&end=2026-11-19&api_key=YOUR_API_KEY"
);
const data = await res.json();
console.log(data.rates.FED_FUNDS);
PHP
<?php
$params = http_build_query([
"symbols" => "FED_FUNDS",
"period" => "monthly",
"start" => "2025-11-19",
"end" => "2026-11-19",
"api_key" => "YOUR_API_KEY"
]);
$url = "https://interestratesapi.com/api/v1/ohlc?{$params}";
$data = json_decode(file_get_contents($url), true);
print_r($data["rates"]["FED_FUNDS"]);
?>
Sample JSON
Field notes:
- period: YYYY-MM for monthly aggregation
- open/high/low/close: computed from the daily series within that period
- data_points: number of observations included in the aggregation window
Practical tip: You can compute a monthly “average” rate using your own logic (e.g., simple mean of daily values or day-count-weighted), or rely on close as the month-end marker depending on your analytics needs.
Endpoint 7: Convert (loan interest cost comparison)
Convert compares the simple-interest cost of a loan at the latest rates of two symbols. Even when focusing on FED_FUNDS, this endpoint helps you articulate the cost difference versus another policy or reference rate for tooling, disclosures, or decision support.
cURL
Python (requests)
import requests
params = {
"from": "FED_FUNDS",
"to": "ECB_MRO",
"amount": 100000,
"term_months": 12,
"api_key": "YOUR_API_KEY"
}
resp = requests.get("https://interestratesapi.com/api/v1/convert", params=params)
data = resp.json()
print(data["from"]["total_payment"], data["to"]["total_payment"])
JavaScript (fetch)
const res = await fetch(
"https://interestratesapi.com/api/v1/convert?from=FED_FUNDS&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY"
);
const data = await res.json();
console.log(data.difference.rate_spread, data.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"] . PHP_EOL;
?>
Sample JSON
Field notes:
- rate: latest annualized percentage for each symbol
- total_interest and total_payment: computed under simple interest assumptions
- difference.rate_spread: from.rate − to.rate in percentage points
Practical implementation details
Publication frequency and business days
Interest-rate series typically observe business day calendars and may not update on weekends or U.S. market holidays. Rely on the dates field to anchor your downstream logic and avoid assuming daily calendar continuity.
Caching and refresh strategy
- Cache by symbol and effective date: FED_FUNDS@2026-10-01
- Poll the latest endpoint at a cadence aligned to expected publication timing rather than high-frequency pulls
- Leverage rate limit headers (X-RateLimit-*) to tune client behavior if your runtime inspects response headers
Error handling
All endpoints return a JSON shape with success=false and a plaintext error message on failure. Handle common HTTP codes:
- 401: Missing or invalid api_key
- 403: Account not active
- 404: No data for the date/range or symbol filter
- 422: Validation errors (check date formats Y-m-d and valid symbols)
- 429: Quota exhausted (observe Retry-After and X-RateLimit-Reset)
Compute a spread from the returned value
If your product prices loans at “FED_FUNDS + X bps”, compute the total benchmark plus spread as:
all_in_rate_pct = fed_funds_rate_pct + (spread_bps / 100.0)
For example, if spread_bps is an input from your pricing rules engine, add it to the returned FED_FUNDS rate to produce an annualized all-in percentage for display or downstream calculations. Do not assume the returned value is already adjusted by your product-specific spread.
Compute a monthly payment from the returned value
To estimate a fixed monthly payment from an annual rate (percent) returned by the API, use the amortizing loan formula:
r_month = (annual_rate_pct / 100.0) / 12.0
payment = principal * r_month / (1 - (1 + r_month) ** (-term_months))
This converts the annualized percentage to a monthly rate and applies the standard annuity formula. Use this in combination with the latest FED_FUNDS plus your internal spread to quote borrower payments in a mortgage or line-of-credit UI. If you need simple interest instead, multiply principal by annual_rate_pct/100 and pro-rate by term_months/12.
Interpreting time series and OHLC together
- Use /timeseries for full-resolution analytics and backtests
- Use /ohlc to compress to monthly or quarterly values for charting and reporting
- Combine with /fluctuation to show a concise summary of moves over a period
Use cases tailored to FED_FUNDS
- Funding dashboards: Track FED_FUNDS and trigger notifications when the rate changes
- Loan pricing engines: Calculate “benchmark + spread” offers and monthly payments
- Macro research: Build regressions on FED_FUNDS and downstream credit indices
- Treasury & cash: Compare simple interest costs across reference rates using /convert
Explore more at interestratesapi.com and review implementation notes in the MCP.
Putting it together: a minimal integration flow
- Confirm the FED_FUNDS symbol via /symbols and store metadata (currency, frequency)
- Pull /latest for FED_FUNDS and cache it using dates.FED_FUNDS
- For charts, call /timeseries and, if needed, /ohlc for monthly aggregation
- Show a period change card using /fluctuation over the desired horizon
- Quote payment estimates using the amortization formula with your internal spread
- Optionally compare benchmark costs with /convert to support product selection
Complete endpoint recap with FED_FUNDS
- /symbols: discover FED_FUNDS metadata and frequency
- /latest: the most recent rate and its effective date
- /historical: reproducible value on a date (month-end within month for monthly symbols)
- /timeseries: continuous historical map for charts and models
- /fluctuation: start/end change and period high/low
- /ohlc: monthly, weekly, or quarterly OHLC computed from daily data
- /convert: total simple-interest comparison between two symbols (e.g., FED_FUNDS vs. ECB_MRO)
All endpoints are HTTP GET and require api_key in the query string. The base URL is always https://interestratesapi.com/api/v1/.
FAQ
How do I interpret the effective date if I request a historical value mid-month?
For monthly symbols, the API returns the last day with data in that month. Always use the date returned in the payload as your canonical as-of date for storage and display.
Are FED_FUNDS values business-day aware?
Yes. Expect updates on business days and gaps on weekends and U.S. holidays. Use the date keys in /timeseries and the dates map in /latest for alignment.
What should I cache against to avoid redundant reprocessing?
Cache each symbol by the effective date. When dates.FED_FUNDS is unchanged, you likely don’t need to refresh downstream calculations.
How do I compute a benchmark-plus-spread rate?
Add your spread in basis points to the returned annualized percentage: all_in_rate_pct = fed_funds_pct + spread_bps / 100.
What errors should my client handle explicitly?
Handle 401/403 for auth and account status, 404 if no data is available for the requested date/range, 422 for validation issues, and 429 with Retry-After/X-RateLimit-Reset for throttling.
Start integrating FED_FUNDS in minutes. Use the Register link to get your API key, then wire the GET endpoints into your stack. For detailed method contracts and examples, see the MCP. You can also browse interestratesapi.com for more central bank and interbank benchmarks aligned to your workflows.