Fed Funds (FED_FUNDS) Rate Today

You need the Federal Funds Effective Rate (FED_FUNDS) in your application today, and you want a clean way to fetch, cache, compare, and display it for pricing, risk, and treasury workflows. By the end of this article, you will retrieve the current FED_FUNDS value over HTTPS, contrast it with prior periods, compute changes, and wire a small React widget that refreshes the live rate from a reliable REST endpoint.

What the FED_FUNDS rate tells markets and borrowers right now

FED_FUNDS is the effective rate at which depository institutions lend reserve balances overnight. Developers, analysts, and traders monitor it because it anchors short-term USD funding costs, drives bank prime rates and floating-rate loans, and ripples through discounting curves and hedge models. In software, the typical jobs are to pull the latest value, line it up against comparable dates (last month, last year), and compute spreads and lending costs.

In the Interest Rates API, FED_FUNDS is a central bank benchmark for USD. The API provides the rate as a percentage (for example, 3.75 means 3.75% per annum). Effective dates help you decide the correct snapshot for valuation, accruals, and audit trails.

Try Interest Rates API for fast access to central bank policy benchmarks and interbank references over a simple REST interface.

Fetch the latest FED_FUNDS value

The /latest endpoint returns the current value and effective date. All endpoints are GET-only and use the api_key query parameter for authentication.

cURL (official sample)

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

JSON (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 this response:

• rates.FED_FUNDS is the latest effective annualized rate in percent (3.75 means 3.75%).
• date is the response-wide date, and dates.FED_FUNDS is the symbol-specific effective date. Use dates.FED_FUNDS for point-in-time logic.
• currencies.FED_FUNDS confirms the currency base (USD).

Python (requests)

import requests

resp = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="FED_FUNDS", api_key="YOUR_API_KEY")
)
data = resp.json()
rate = data["rates"]["FED_FUNDS"] # e.g., 3.75 (percent per annum)
effective_date = data["dates"]["FED_FUNDS"] # e.g., "2026-09-01"
print("FED_FUNDS:", rate, "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 rate = data.rates.FED_FUNDS; // percent per annum
const effDate = data.dates.FED_FUNDS; // effective date string (YYYY-MM-DD)
console.log('FED_FUNDS', rate, 'on', effDate);

PHP

<?php
$url = "https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS&api_key=YOUR_API_KEY";
$ctx = stream_context_create([
"http" => ["method" => "GET", "header" => "Accept: application/json\r\n"]
]);
$json = file_get_contents($url, false, $ctx);
$data = json_decode($json, true);

$rate = $data["rates"]["FED_FUNDS"];
$effectiveDate = $data["dates"]["FED_FUNDS"];

echo "FED_FUNDS: {$rate}% on {$effectiveDate}\n";

Publication frequency, business days, and effective dates

In this article we focus on the FED_FUNDS symbol, which is provided as a monthly effective measure. For monthly symbols, the API notes that the last day with data within that month is used for the effective date; in the sample above, that is 2026-09-01 for the monthly snapshot.

Consider these integration details:

• Frequency and timing: For monthly symbols like FED_FUNDS, expect one value per month. If you need a daily series, the API also provides FED_FUNDS_DAILY (not covered here), but keep your symbol usage consistent across your application.
• Business days: If a publishing date falls on a weekend or holiday, the last business day in the month is used as the effective date. Always read dates.FED_FUNDS to anchor calculations.
• Caching: For monthly benchmarks, cache aggressively for the remainder of the month. If you poll intra-month, add ETag- or time-based cache controls in your stack. For intraday widgets, a refresh every few hours is more than sufficient for monthly series.
• Error and rate limits: Watch for 429 with Retry-After and X-RateLimit-* headers. Add exponential backoff and avoid retry storms.

Explore Interest Rates API features for additional symbols and integration patterns.

Compare today’s FED_FUNDS to last month and last year

To contrast today’s monthly rate with prior periods, call /historical twice: one month ago and one year ago. The API resolves a monthly symbol to the last available day in that month.

cURL

# Last month (example date — use the prior month boundary or a day within it)
curl "https://interestratesapi.com/api/v1/historical?date=2026-08-15&symbols=FED_FUNDS&api_key=YOUR_API_KEY"

# One year ago
curl "https://interestratesapi.com/api/v1/historical?date=2025-09-15&symbols=FED_FUNDS&api_key=YOUR_API_KEY"

Python

import datetime as dt
import requests

api = "https://interestratesapi.com/api/v1/historical"
api_key = "YOUR_API_KEY"

def fetch_hist(d):
r = requests.get(api, params=dict(date=d, symbols="FED_FUNDS", api_key=api_key))
r.raise_for_status()
return r.json()["rates"]["FED_FUNDS"], r.json().get("date")

today = dt.date.today()
# Choose mid-month anchors for clarity; API will resolve to last day with data in that month for monthly symbols
last_month_anchor = (today.replace(day=15) - dt.timedelta(days=31)).replace(day=15).isoformat()
last_year_anchor = today.replace(year=today.year - 1, day=15).isoformat()

curr = requests.get("https://interestratesapi.com/api/v1/latest",
params=dict(symbols="FED_FUNDS", api_key=api_key)).json()
curr_rate = curr["rates"]["FED_FUNDS"]

lm_rate, lm_date = fetch_hist(last_month_anchor)
ly_rate, ly_date = fetch_hist(last_year_anchor)

print(f"FED_FUNDS current: {curr_rate}%")
print(f"Last month (resolved around {lm_date}): {lm_rate}%")
print(f"Last year (resolved around {ly_date}): {ly_rate}%")

Note: Do not hardcode values; always read the rate from the response and use the date that the API returns for correct time alignment.

30‑day change, high, and low via /fluctuation

To summarize the last 30 days of movement, the /fluctuation endpoint returns start_value, end_value, absolute and percent change, plus high and low in the period. The sample below shows the response shape (values are illustrative from the documentation, not current):

cURL

JSON example

How to use it:

• Read change and change_pct to render deltas in dashboards.
• Use high and low for 30‑day bands, alerts, or stress inputs.
• Always bind charts to start_date and end_date from the response for precise windows.

Build a live FED_FUNDS widget in React

This snippet polls the /latest endpoint and displays the rate and effective date. Because FED_FUNDS is monthly, a modest refresh interval is appropriate.

React (functional component)

import React from 'react';

export default function FedFundsWidget() {
const [rate, setRate] = React.useState(null);
const [effDate, setEffDate] = React.useState(null);
const [error, setError] = React.useState(null);

const fetchRate = React.useCallback(async () => {
try {
const res = await fetch(
'https://interestratesapi.com/api/v1/latest?symbols=FED_FUNDS&api_key=YOUR_API_KEY'
);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();
setRate(data?.rates?.FED_FUNDS ?? null);
setEffDate(data?.dates?.FED_FUNDS ?? data?.date ?? null);
setError(null);
} catch (e) {
setError(e.message);
}
}, []);

React.useEffect(() => {
fetchRate();
const id = setInterval(fetchRate, 60 * 60 * 1000); // refresh hourly is safe for monthly series
return () => clearInterval(id);
}, [fetchRate]);

if (error) return <div>FED_FUNDS: error {error}</div>;
if (rate == null) return <div>Loading FED_FUNDS…</div>;
return (
<div>
<div>FED_FUNDS: <strong>{rate}%</strong></div>
<div>Effective: {effDate}</div>
</div>
);
}

Time series and OHLC for analytics

Use /timeseries for a range you want to plot or regress on. For monthly FED_FUNDS, specify start and end over months to get one value per month. For candlestick-style summaries, use /ohlc; it is computed on-the-fly from the underlying daily data when applicable, but you can still request monthly periods to obtain open/high/low/close across your range.

cURL examples

# Monthly time series (choose dates bounding the months you need)
curl "https://interestratesapi.com/api/v1/timeseries?start=2025-10-01&end=2026-10-31&symbols=FED_FUNDS&api_key=YOUR_API_KEY"

# OHLC over the same window at monthly granularity
curl "https://interestratesapi.com/api/v1/ohlc?symbols=FED_FUNDS&period=monthly&start=2025-10-01&end=2026-10-31&api_key=YOUR_API_KEY"

OHLC JSON example

Interpretation tips:

• For monthly FED_FUNDS, the open/close capture the first and last available observations within each month; high/low show the range inside the period.
• Use data_points for QA and completeness checks across your pipeline.

Compute spreads and monthly payments from the API value

FED_FUNDS is returned in percent per annum. To compute a spread versus another rate series you already have, subtract the two percentages and retain sign:

// spread in percentage points
const fedFunds = data.rates.FED_FUNDS; // e.g., 3.75 (percent)
const other = 4.10; // another benchmark from your stack
const spread = other - fedFunds; // +0.35 means other is 35 bps above Fed Funds

For a simple monthly payment estimate at an annual rate r% on principal P over n months using an amortizing schedule, convert to a monthly rate and apply the annuity formula:

function monthlyPayment(principal, annualRatePct, termMonths) {
const r = (annualRatePct / 100) / 12;
if (r === 0) return principal / termMonths;
return principal * (r * Math.pow(1 + r, termMonths)) / (Math.pow(1 + r, termMonths) - 1);
}

If you want a quick comparison between two benchmarks at their latest values, the /convert endpoint computes total interest for a simple loan (not amortizing) over a term you specify:

cURL

JSON example

This response includes both rates, effective dates, total interest on a simple loan basis, and a spread. For amortized loans, use the monthlyPayment function above instead.

Symbol discovery and metadata

To enumerate central bank symbols in USD (including FED_FUNDS), query /symbols with filters. This is useful for feature flags or surfacing alternatives (for example, FED_DISCOUNT_RATE or FED_IORB) in admin consoles or APIs you expose to your clients.

cURL

JSON example

Use this metadata to display descriptions, categories, and frequencies in UI controls or API responses to your own clients. Even when you cache symbol metadata, refresh it periodically to capture new instruments.

Error handling, reliability, and caching patterns

• Authentication and authorization: A 401 means a missing or invalid api_key; a 403 means the account lacks an active plan. Always include the api_key as a query parameter.
• Validation: A 422 indicates malformed input (for example, wrong date format). Keep dates as YYYY-MM-DD, and ensure start ≤ end for ranges.
• No data: A 404 is returned when no symbols match or the date/range has no data. Some 404 responses include a details field with available ranges—surface this in observability logs.
• Rate limiting: A 429 will include Retry-After plus X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset. Implement backoff and fail-open if your UI can tolerate stale cached values for monthly series.
• Caching guidance: For FED_FUNDS (monthly), cache the /latest response for the rest of the month or until you detect a new dates.FED_FUNDS. For historical and OHLC data, cache indefinitely as it is immutable. For /fluctuation, cache for the life of your visualization or until the end bound moves.

For more developer details, see the MCP page and Get started with Interest Rates API.

Why developers and traders track FED_FUNDS daily

Even if you primarily consume the monthly FED_FUNDS, funding markets react to policy expectations every day. Changes in FED_FUNDS levels and path assumptions spill into SOFR curves, bank lending rates, mortgage repricing, and the discount factors inside DCFs and ALM systems. Pulling the latest value programmatically lets you automate borrow/deposit pricing, position risk, and CFO dashboards without manual updates, while historical comparisons help you build alerting, guardrails, and narrative context in your app.

Try Interest Rates API to integrate this benchmark alongside interbank references like SOFR and SONIA using the same interface.

FAQ

How is FED_FUNDS expressed in the API?
As a percent per annum (for example, 3.75 means 3.75%). Divide by 100 to obtain a decimal rate for math functions.

Which date should I display?
Use dates.FED_FUNDS from the /latest response for precise effective dating. For monthly symbols, the API uses the last day with data in that month.

How often should I refresh?
For FED_FUNDS (monthly), hourly or even daily refresh is sufficient. Cache the stable value for the remainder of the month unless your UI mandates frequent polling.

What if my selected date is a weekend or holiday?
For monthly symbols, the API resolves to the last available day with data in that month. Always use the date provided in the response.

Can I compute a loan comparison directly via the API?
Yes. Use /convert with from=FED_FUNDS, to=YOUR_OTHER_SYMBOL, amount, and term_months. It returns total interest and payments at the latest rates for a simple loan model.

Ready to ship your integration? Register for an API key, then start building with FED_FUNDS and related benchmarks. Explore Interest Rates API features and wire the endpoints above to your pricing, treasury, and analytics flows.