Fed Funds (FED_FUNDS) Rate History

You need the Federal Funds Effective Rate in your codebase with reliable timestamps and machine-readable JSON. By the end of this guide, you’ll query the FED_FUNDS history, compute spreads and loan costs, and build time series analytics using the Interest Rates API over simple GET requests with the api_key parameter.

What the Fed Funds (FED_FUNDS) rate represents

FED_FUNDS is the Federal Funds Effective Rate: the interest rate at which depository institutions lend reserve balances to each other overnight. It is a core USD policy benchmark that anchors money-market pricing, cascades into interbank rates like SOFR and OBFR, and influences lending benchmarks and treasury cash models.

In the Interest Rates API, FED_FUNDS is delivered as a numeric percentage (e.g., 3.88 means 3.88% per annum). This article focuses on the monthly series (symbol: FED_FUNDS). If you need a higher-frequency series, you can also use FED_FUNDS_DAILY; both symbols are part of the central_bank category.

Key practicals to keep in mind when working with this symbol in production:

• Frequency: monthly (for FED_FUNDS). When requesting specific dates via the historical endpoint, the API uses the last day with data within that month.
• Calendar and business days: central bank and interbank benchmarks observe publication calendars. For monthly FED_FUNDS, treat the value as the month’s effective series point; for daily variants, weekends and US federal holidays typically show no new observations.
• Units: values are percentages per annum, not basis points or decimals. Convert to decimals for math (e.g., 3.88% = 0.0388).
• Effective dates: the latest endpoint returns both a top-level “date” and a “dates” map keyed by symbol so you can align time series precisely.
• Caching: cache by symbol and date granularity (e.g., month) to control request volume, and respect 429 headers if you are rate limited.

All requests below use the base URL https://interestratesapi.com/api/v1/ and are authenticated by adding the api_key query parameter. Every endpoint is a GET. Explore the platform at interestratesapi.com and consult the MCP to understand capabilities and schema.

Discovering the symbol and metadata

Before fetching values, confirm that FED_FUNDS is available and note its category, currency, and description using the symbols endpoint.

Endpoint: GET /api/v1/symbols

Filter for central bank USD symbols to see FED_FUNDS:

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

Sample JSON response:

{
    "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
}

How to read it:

• symbol: use “FED_FUNDS” in other endpoints.
• currency_code: always expect USD for this symbol.
• frequency: your downstream logic should not assume frequency; read it via this endpoint or via the timeseries frequencies map. This article focuses on the monthly FED_FUNDS series; a daily variant (FED_FUNDS_DAILY) is also available when you need daily data.

Code examples

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")
)
print(resp.json())

JavaScript (fetch):

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);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_API_KEY";
$resp = file_get_contents($url);
echo $resp;

Get the latest FED_FUNDS value

Use the latest endpoint to retrieve the current published value along with the effective date and currency mapping. This is the canonical starting point for dashboards and alerts.

Endpoint: GET /api/v1/latest

Official cURL (use exactly as shown; authentication via api_key in the query string):

Official JSON:

How to read it:

• rates: a map from symbol to the latest percentage value (3.88 means 3.88%).
• dates: a map from symbol to the effective date (for monthly symbols, a date within that month used by the API).
• currencies: currency per symbol; always USD for FED_FUNDS.
• date: top-level date for the payload; use the per-symbol dates map if you request multiple symbols.

Language samples for latest

Python (requests):

import requests

response = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="FED_FUNDS", api_key="YOUR_API_KEY")
)
data = response.json()
rate_pct = data["rates"]["FED_FUNDS"]
effective_date = data["dates"]["FED_FUNDS"]
print("Fed Funds:", rate_pct, "Effective date:", effective_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 ratePct = data.rates.FED_FUNDS;
const effDate = data.dates.FED_FUNDS;
console.log("Fed Funds", ratePct, "on", effDate);

PHP:

<?php
$url = "https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS&api_key=YOUR_API_KEY";
$json = file_get_contents($url);
$data = json_decode($json, true);
$rate = $data["rates"]["FED_FUNDS"];
$date = $data["dates"]["FED_FUNDS"];
echo "Fed Funds $rate% on $date";

Query the value on a specific date

For backfilled calculations (e.g., month-end NAVs or period resets), request a single date. For monthly series, the API returns the last available day within that month.

Endpoint: GET /api/v1/historical

cURL:

JSON response:

Notes:

• date is your requested date.
• For monthly FED_FUNDS, the returned value corresponds to the last day with data in June 2025.

Language samples for historical

Python (requests):

import requests

params = dict(date="2025-06-15", symbols="FED_FUNDS", api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/historical", params=params)
print(r.json())

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);
console.log(await res.json());

PHP:

<?php
$query = http_build_query([
"date" => "2025-06-15",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
echo file_get_contents("https://interestratesapi.com/api/v1/historical?$query");

Pull a FED_FUNDS time series

Time series power charts, statistical models, and backtests. The API returns a map of date to value with explicit start and end bounds, plus a frequencies map per symbol that your code should read to understand the cadence for each series.

Endpoint: GET /api/v1/timeseries

cURL:

JSON response:

Notes:

• rates.FED_FUNDS is a date-indexed map of percentage values.
• frequencies tells you the symbol’s cadence as returned in this example. For the monthly FED_FUNDS series, your production response will indicate monthly frequency; adjust aggregation and charting accordingly.

Language samples for timeseries

Python (requests):

import requests

params = dict(
start="2025-11-05",
end="2026-11-05",
symbols="FED_FUNDS",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/timeseries", params=params)
ts = r.json()
series = ts["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-05&end=2026-11-05&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const res = await fetch(url);
const payload = await res.json();
const series = payload.rates.FED_FUNDS;
Object.entries(series).forEach(([date, value]) => {
console.log(date, value);
});

PHP:

<?php
$params = http_build_query([
"start" => "2025-11-05",
"end" => "2026-11-05",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
echo file_get_contents("https://interestratesapi.com/api/v1/timeseries?$params");

Measure change over a range

To summarize a period move (e.g., quarter-over-quarter), use fluctuation for start/end values, absolute change, percentage change, and in-range high/low.

Endpoint: GET /api/v1/fluctuation

cURL:

JSON response:

How to use it:

• change is end_value − start_value in percentage points.
• change_pct is (change / start_value) × 100, null if start_value is 0.
• high/low are the extrema within the period.

Language samples for fluctuation

Python (requests):

import requests

params = dict(
start="2025-11-05",
end="2026-11-05",
symbols="FED_FUNDS",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/fluctuation", params=params)
print(r.json())

JavaScript (fetch):

const url = "https://interestratesapi.com/api/v1/fluctuation?start=2025-11-05&end=2026-11-05&symbols=FED_FUNDS&api_key=YOUR_API_KEY";
const res = await fetch(url);
const stats = await res.json();
console.log(stats.rates.FED_FUNDS);

PHP:

<?php
$query = http_build_query([
"start" => "2025-11-05",
"end" => "2026-11-05",
"symbols" => "FED_FUNDS",
"api_key" => "YOUR_API_KEY"
]);
echo file_get_contents("https://interestratesapi.com/api/v1/fluctuation?$query");

Get OHLC candlesticks computed from daily data

When you need chart-ready monthly or weekly candles, request OHLC. The API computes these candles on-the-fly from the daily observations available internally.

Endpoint: GET /api/v1/ohlc

cURL:

JSON response:

Field notes:

• period: the aggregation period you requested (weekly, monthly, or quarterly).
• open/high/low/close: computed from the underlying daily series within that period.
• data_points: number of daily observations used for the candle.

Language samples for ohlc

Python (requests):

import requests

params = dict(
symbols="FED_FUNDS",
period="monthly",
start="2025-11-05",
end="2026-11-05",
api_key="YOUR_API_KEY"
)
r = requests.get("https://interestratesapi.com/api/v1/ohlc", params=params)
print(r.json())

JavaScript (fetch):

const url = "https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS&period=monthly&start=2025-11-05&end=2026-11-05&api_key=YOUR_API_KEY";
const res = await fetch(url);
const ohlc = await res.json();
console.log(ohlc.rates.FED_FUNDS);

PHP:

<?php
$params = http_build_query([
"symbols" => "FED_FUNDS",
"period" => "monthly",
"start" => "2025-11-05",
"end" => "2026-11-05",
"api_key" => "YOUR_API_KEY"
]);
echo file_get_contents("https://interestratesapi.com/api/v1/ohlc?$params");

Compare interest cost or compute a spread

Developers often need loan cost comparisons between two benchmarks or a simple spread. You can either compute spreads locally from latest values or use the convert endpoint to receive a precomputed comparison for a notional and term.

Endpoint: GET /api/v1/convert

cURL:

JSON response:

How to use it:

• difference.rate_spread is the arithmetic spread (in percentage points) between the two latest rates.
• total_interest assumes a simple-rate loan for the specified amount and term_months using the latest rate for each symbol.

Local spread or monthly payment calculation

• Spread: spread = latest(FED_FUNDS) − latest(OtherRate). Read both from latest.rates and subtract.
• Monthly payment from a simple rate: interest_amount = principal × (rate_pct / 100) × (term_months / 12). For amortizing loans, convert rate to a monthly decimal r = (rate_pct / 100) / 12, then payment = P × r / (1 − (1 + r)^(-n)). Use this with the latest FED_FUNDS value after deciding your loan’s pricing convention.

Language samples for convert

Python (requests):

import requests

params = dict(from="FED_FUNDS", to="ECB_MRO", amount=100000, term_months=12, api_key="YOUR_API_KEY")
r = requests.get("https://interestratesapi.com/api/v1/convert", params=params)
print(r.json())

JavaScript (fetch):

const url = "https://interestratesapi.com/api/v1/convert?from=FED_FUNDS&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_API_KEY";
const res = await fetch(url);
console.log(await res.json());

PHP:

<?php
$query = http_build_query([
"from" => "FED_FUNDS",
"to" => "ECB_MRO",
"amount" => 100000,
"term_months" => 12,
"api_key" => "YOUR_API_KEY"
]);
echo file_get_contents("https://interestratesapi.com/api/v1/convert?$query");

Error handling, rate limits, and caching

Build robust clients that handle validation and runtime errors, and cache stable data to reduce calls.

• 401 Unauthorized: missing or invalid api_key. Verify you append api_key=YOUR_API_KEY to every URL.
• 403 Forbidden: account has no active plan.
• 404 Not Found: no symbols matched or no data for the date/range. Some 404s include a details field with available date ranges; read and adjust your query.
• 422 Validation: wrong date format (must be Y-m-d) or invalid symbol name.
• 429 Rate limited: check Retry-After and X-RateLimit-* headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) and back off.

Caching guidance:

• Cache latest by symbol until the next expected publication window for that symbol (for monthly series, a day-level TTL aligned to your ingestion time usually suffices).
• Cache immutable historical data by symbol+date indefinitely or with long TTLs.
• For timeseries, cache by the exact start/end range; consider ETag-style keys built from query params.

See the docs on interestratesapi.com and the MCP for endpoint behavior.

How to align effective dates and business calendars

When you read the latest endpoint for FED_FUNDS, prefer the dates map for symbol-specific timing. For monthly series, downstream calculations (e.g., monthly repricing) typically use the month as the valuation bucket. For historical queries, the API note applies: for monthly symbols, the last day with data within that month is used.

For daily operations (risk or intraday PnL demos), consider FED_FUNDS_DAILY if you need per-day ticks. If you remain on the monthly FED_FUNDS, don’t forward-fill daily charts without labeling; instead, aggregate to month and display the month’s value as a step series or monthly marker.

End-to-end examples across all seven endpoints

This section summarizes all endpoints with cURL, plus Python, JavaScript, and PHP samples you can paste into your pipelines. Every endpoint is GET and uses api_key as a query parameter.

• Catalogue: /symbols — discover FED_FUNDS and read metadata, including currency and description.
• Latest: /latest — current value and effective date map for FED_FUNDS.
• Historical: /historical — point-in-time lookups, aligning to month-end for monthly FED_FUNDS.
• Timeseries: /timeseries — build a date-indexed series for charts and regressions.
• Fluctuation: /fluctuation — compute change and range stats over a window.
• OHLC: /ohlc — generate candles for charting from underlying daily data.
• Convert: /convert — compare simple loan interest cost and spread at the latest rates.

If you plan to ship a production integration, create a small wrapper that:

• Builds URLs by concatenating the base URL (https://interestratesapi.com/api/v1/) and query strings with api_key.
• Normalizes all percentage values into decimal form for math, then converts back to percentages for display.
• Inspects frequencies and dates fields to avoid frequency mismatches across series.
• Implements retry/backoff for HTTP 429 using Retry-After and caches stable data.

Use cases with FED_FUNDS

• Interest rate dashboards: show the latest FED_FUNDS reading with historical sparkline and monthly candles from /ohlc.
• Lending and treasury models: compute simple spreads relative to internal transfer prices or to ECB_MRO for cross-currency policy comparisons using /latest or /convert.
• Macro research: pull multi-year /timeseries for regressions against inflation or unemployment data; use /fluctuation to quickly annotate tightening/easing cycles.
• Risk and ALM: roll monthly repricing ladders with /historical (month-end alignment) and lock values to month buckets.

You can start integrating in minutes at Register. For schema and field definitions, see the MCP.

FAQ

Is FED_FUNDS returned as a percentage or decimal?
Percent. For example, 3.88 means 3.88% per annum. Convert to decimals in your math by dividing by 100.

How do I interpret the dates in latest versus the dates map?
Use the dates map keyed by symbol for alignment when you request multiple symbols. The top-level date is the payload’s reference date; symbol-level dates ensure precise per-series timestamps.

What happens if I request /historical for a monthly symbol with a mid-month date?
For monthly symbols like FED_FUNDS, the API uses the last day with data within that month, so your retrieval aligns with the month’s published observation.

How should I cache FED_FUNDS in production?
Cache latest by symbol with a TTL that covers your ingestion window (e.g., day-level), cache historical data by date indefinitely, and consider ETag-like cache keys for timeseries by start/end. Always handle 429 with Retry-After.

How can I compute a monthly loan payment from the FED_FUNDS value?
Decide your pricing convention. For a simple-rate estimate: interest = principal × (rate_pct / 100) × (term_months / 12). For a standard amortizing loan: payment = P × r / (1 − (1 + r)^(−n)), with r = (rate_pct/100)/12 and n = term_months.

Bring the Fed Funds rate into your fintech stack today. Use the links below to get an API key and ship your integration, then explore more endpoints and symbols in the docs:

• Register
• MCP

Also see the homepage for platform overview: interestratesapi.com and Get started with Interest Rates API.