Your team needs machine-readable access to the Federal Reserve’s Interest on Reserve Balances (IORB) so you can power dashboards, pricing, and risk models. By the end of this guide, you will retrieve FED_IORB over HTTPS, understand how to interpret dates and units, compute spreads and loan impacts from the returned value, and integrate all seven Interest Rates API endpoints into your stack with cURL, Python, JavaScript, and PHP.
What FED_IORB Represents and Why It Matters
FED_IORB is the Interest on Reserve Balances set by the Federal Reserve. It is a key administered rate that helps set the floor of the U.S. overnight interest rate corridor and influences money market conditions. In practice, FED_IORB anchors many short-term benchmarks and informs funding costs for banks and liquidity managers.
For developers and analysts, FED_IORB provides:
- A stable policy lever to track stance of monetary policy between FOMC decisions.
- A reference rate to compare against market-based benchmarks (e.g., SOFR) for spreads and models.
- A daily series usable in backtests, stress testing, and interest accrual logic.
All data in this article is delivered by interestratesapi.com as JSON over HTTPS via GET requests authenticated with an api_key query parameter.
Data Conventions: Units, Dates, Frequency, and Caching
Units: FED_IORB is expressed as an annualized percentage (for example, 3.9 means 3.9% per annum). When you compute costs, divide by 100 to convert percentage to a decimal rate (e.g., 3.9% = 0.039).
Dates and timezone: Dates in responses are in ISO format (Y-m-d). For daily central bank rates like FED_IORB, the date indicates the effective date of the rate. Business days: Daily policy rates may not update on weekends or U.S. federal holidays. Time series endpoints will include only available effective dates.
Frequency: FED_IORB has daily frequency as reported in metadata and time series responses.
Caching guidance: Cache static discovery (such as the symbols catalog) for hours. Cache latest values briefly (for example, 5–15 minutes) and time series for longer intervals depending on your update cycle. Respect rate-limit headers when present.
Discoverability: List the FED_IORB Symbol
Use the symbols catalog to filter central bank rates and confirm availability of FED_IORB. The response includes metadata like currency, frequency, and a description. Authentication is via the api_key query parameter.
cURL: /api/v1/symbols
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_IORB"
JSON (example)
{
"success": true,
"date": "2026-11-20",
"base": "USD",
"rates": {
"FED_IORB": 3.9
},
"dates": {
"FED_IORB": "2026-11-20"
},
"currencies": {
"FED_IORB": "USD"
},
"base_filter_note": null
}
Notes:
- The symbols array includes objects with fields such as symbol, name, category, frequency, and description.
- Filter by base=USD and category=central_bank to narrow to U.S. policy rates, including FED_IORB.
Python (requests)
import requests
resp = requests.get(
'https://interestratesapi.com/api/v1/symbols',
params=dict(category='central_bank', base='USD', api_key='YOUR_KEY')
)
symbols = resp.json()
print(symbols.get('success'), symbols.get('count'))
JavaScript (fetch)
const response = await fetch(
'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY'
);
const data = await response.json();
console.log(data.success, data.count);
PHP
<?php
$url = 'https://interestratesapi.com/api/v1/symbols?category=central_bank&base=USD&api_key=YOUR_KEY';
$json = file_get_contents($url);
$data = json_decode($json, true);
echo $data['success'] ? "OK\n" : "Error\n";
?>
Latest FED_IORB: Read the Current Effective Level
Use the latest endpoint to fetch the most recent effective IORB value and its date. Authentication uses the api_key query parameter.
OFFICIAL cURL (use verbatim)
OFFICIAL JSON (use verbatim)
How to read:
- rates is a symbol-to-value map: FED_IORB → 3.9 (interpreted as 3.9% per annum).
- date is the response date; dates maps each symbol to its own effective date.
- currencies gives the currency code per symbol (USD here).
Python (requests)
import requests
r = requests.get(
'https://interestratesapi.com/api/v1/latest',
params=dict(api_key='YOUR_API_KEY', symbols='FED_IORB')
)
j = r.json()
iorb = j['rates']['FED_IORB'] # e.g., 3.9 means 3.9% p.a.
iorb_date = j['dates']['FED_IORB']
print(iorb, iorb_date)
JavaScript (fetch)
const res = await fetch(
'https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_IORB'
);
const out = await res.json();
const iorb = out.rates['FED_IORB']; // annualized percentage
const iorbDate = out.dates['FED_IORB']; // ISO date
console.log(iorb, iorbDate);
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_IORB';
$j = file_get_contents($u);
$d = json_decode($j, true);
$rate = $d['rates']['FED_IORB'];
$date = $d['dates']['FED_IORB'];
echo "FED_IORB: {$rate}% on {$date}\n";
?>
Historical FED_IORB: Value on a Specific Date
Use the historical endpoint to retrieve FED_IORB on a target date. If the symbol were monthly, the API would return the last day with data in that month; for daily FED_IORB, you will receive the value for that date if available.
cURL: /api/v1/historical
JSON (example)
Key fields:
- date is the requested date.
- rates.FED_IORB is the rate on that date (percentage per annum).
- currencies confirms USD for FED_IORB.
Python (requests)
import requests
resp = requests.get(
'https://interestratesapi.com/api/v1/historical',
params=dict(date='2025-06-15', symbols='FED_IORB', api_key='YOUR_KEY')
)
h = resp.json()
print(h['rates']['FED_IORB'])
JavaScript (fetch)
const r = await fetch(
'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_IORB&api_key=YOUR_KEY'
);
const j = await r.json();
console.log(j.rates['FED_IORB']);
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=FED_IORB&api_key=YOUR_KEY';
$j = file_get_contents($u);
$d = json_decode($j, true);
echo $d['rates']['FED_IORB'] . "\n";
?>
Time Series: FED_IORB Between Two Dates
Use the timeseries endpoint to fetch daily FED_IORB across a defined window. This is ideal for charts, moving averages, and backtests.
cURL: /api/v1/timeseries
JSON (example)
How to use:
- rates.FED_IORB is a date-indexed object, each value a percent per annum.
- frequencies confirms daily cadence.
- Missing weekends/holidays reflect no publication days.
Python (requests)
import requests
ts = requests.get(
'https://interestratesapi.com/api/v1/timeseries',
params=dict(start='2025-11-21', end='2026-11-21', symbols='FED_IORB', api_key='YOUR_KEY')
).json()
series = ts['rates']['FED_IORB'] # dict of {date: rate}
dates = sorted(series.keys())
first_date = dates[0]
first_value = series[first_date]
print(first_date, first_value)
JavaScript (fetch)
const resp = await fetch(
'https://interestratesapi.com/api/v1/timeseries?start=2025-11-21&end=2026-11-21&symbols=FED_IORB&api_key=YOUR_KEY'
);
const tsData = await resp.json();
const entries = Object.entries(tsData.rates['FED_IORB']); // [[date, value], ...]
console.log(entries.slice(0, 3));
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/timeseries?start=2025-11-21&end=2026-11-21&symbols=FED_IORB&api_key=YOUR_KEY';
$j = file_get_contents($u);
$d = json_decode($j, true);
foreach ($d['rates']['FED_IORB'] as $date => $value) {
echo $date . ': ' . $value . "\n";
}
?>
Fluctuation: FED_IORB Change, High, Low Over a Range
The fluctuation endpoint computes summary statistics for FED_IORB over a period, useful for analytics panels and alerts.
cURL: /api/v1/fluctuation
JSON (example)
Field notes:
- start_value and end_value are the first and last available values in the window.
- change is end_value − start_value; change_pct is percentage change (null if start_value is 0).
- high and low are extrema within the window.
Python (requests)
import requests
fl = requests.get(
'https://interestratesapi.com/api/v1/fluctuation',
params=dict(start='2025-11-21', end='2026-11-21', symbols='FED_IORB', api_key='YOUR_KEY')
).json()
stats = fl['rates']['FED_IORB']
print(stats['change'], stats['change_pct'], stats['high'], stats['low'])
JavaScript (fetch)
const resF = await fetch(
'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-21&end=2026-11-21&symbols=FED_IORB&api_key=YOUR_KEY'
);
const flData = await resF.json();
const s = flData.rates['FED_IORB'];
console.log(s.change, s.change_pct, s.high, s.low);
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/fluctuation?start=2025-11-21&end=2026-11-21&symbols=FED_IORB&api_key=YOUR_KEY';
$j = file_get_contents($u);
$d = json_decode($j, true);
$st = $d['rates']['FED_IORB'];
echo "Δ: {$st['change']} ({$st['change_pct']}%) high={$st['high']} low={$st['low']}\n";
?>
OHLC: Aggregate FED_IORB into Candlestick Periods
For low-latency charting or compressed views, compute OHLC on the fly from daily data.
cURL: /api/v1/ohlc
JSON (example)
Interpretation:
- period specifies the aggregation (monthly by default).
- Each object in rates.FED_IORB includes open, high, low, close, and data_points for that period.
Python (requests)
import requests
ohlc = requests.get(
'https://interestratesapi.com/api/v1/ohlc',
params=dict(symbols='FED_IORB', period='monthly', start='2025-11-21', end='2026-11-21', api_key='YOUR_KEY')
).json()
rows = ohlc['rates']['FED_IORB']
for row in rows:
print(row['period'], row['open'], row['high'], row['low'], row['close'], row['data_points'])
JavaScript (fetch)
const rO = await fetch(
'https://interestratesapi.com/api/v1/ohlc?symbols=FED_IORB&period=monthly&start=2025-11-21&end=2026-11-21&api_key=YOUR_KEY'
);
const dO = await rO.json();
(dO.rates['FED_IORB'] || []).forEach(p => {
console.log(p.period, p.open, p.high, p.low, p.close, p.data_points);
});
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/ohlc?symbols=FED_IORB&period=monthly&start=2025-11-21&end=2026-11-21&api_key=YOUR_KEY';
$j = file_get_contents($u);
$d = json_decode($j, true);
foreach ($d['rates']['FED_IORB'] as $row) {
echo implode(',', [$row['period'], $row['open'], $row['high'], $row['low'], $row['close'], $row['data_points']]) . "\n";
}
?>
Convert: Compare Loan Interest Cost Using FED_IORB
The convert endpoint compares the simple interest cost of a loan priced at two benchmark rates, using the latest value for each symbol. It returns total interest and total payment for the period.
cURL: /api/v1/convert
JSON (example)
Field notes:
- rate is the latest annualized percent for each symbol.
- total_interest and total_payment reflect a simple interest calculation over term_months.
- difference.rate_spread is the arithmetic spread in percentage points; interest_saved is the absolute saving vs. the “from” rate.
Python (requests)
import requests
cmp = requests.get(
'https://interestratesapi.com/api/v1/convert',
params=dict(from='FED_IORB', to='ECB_MRO', amount=100000, term_months=12, api_key='YOUR_KEY')
).json()
print(cmp['difference']['rate_spread'], cmp['difference']['interest_saved'])
JavaScript (fetch)
const rC = await fetch(
'https://interestratesapi.com/api/v1/convert?from=FED_IORB&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY'
);
const dC = await rC.json();
console.log(dC.difference.rate_spread, dC.difference.interest_saved);
PHP
<?php
$u = 'https://interestratesapi.com/api/v1/convert?from=FED_IORB&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY';
$j = file_get_contents($u);
$d = json_decode($j, true);
echo "Spread: " . $d['difference']['rate_spread'] . " Saved: " . $d['difference']['interest_saved'] . "\n";
?>
Practical Computations with FED_IORB
Expressing the rate: A returned value of r (e.g., 3.9) should be interpreted as r% per annum. Convert to decimal as r_decimal = r / 100.
Daily accruals: For simple daily accrual on amount A over n days, with 365-day basis, interest = A × (r_decimal) × (n / 365). Choose 360/365 as per your policy; the API does not enforce a day count convention, so keep it consistent across your systems.
Computing a spread: If you also fetch a comparison benchmark x (e.g., via /latest for another symbol), the spread in basis points is (r − x) × 100. The spread in percentage points is (r − x).
Estimating a monthly payment (interest-only): For interest-only monthly payment on principal P at annual rate r_decimal, monthly interest = P × (r_decimal / 12). For amortizing loans, apply your amortization formula; a common annuity payment formula uses monthly_rate = r_decimal / 12 and payment = P × [monthly_rate × (1 + monthly_rate)^N] / [(1 + monthly_rate)^N − 1], where N is total months. Always derive r_decimal from the API’s percentage.
Error Handling, Rate Limits, and Reliability
APIs return structured errors with success=false and a message in error. Common HTTP codes include:
- 401 for missing/invalid api_key.
- 403 for an account without an active plan.
- 404 when symbols do not match or data is unavailable for the requested range/date.
- 422 for validation errors (e.g., date format not Y-m-d, invalid symbol).
- 429 when you exceed your quota; honor Retry-After and the X-RateLimit-* headers.
Implement retries with backoff on 429 and transient network errors. Cache stable responses as noted earlier. You can always refer to the MCP and the product site interestratesapi.com for more details.
Real-World Uses for FED_IORB in Software
- Dashboards: Display the latest FED_IORB with date, plus a small time series and OHLC summaries over selectable ranges.
- Pricing and treasury: Compute funding spreads to SOFR or other interbank benchmarks, and track fluctuation stats for policy shifts.
- Risk and ALM: Stress scenarios using timeseries windows and summarize drawdowns via fluctuation high/low.
- Research: Backtest reaction functions with daily FED_IORB, compute rolling changes, and annotate effective dates in timelines.
All of these can be implemented on top of the seven endpoints shown above, using simple GET requests with an api_key query parameter. To obtain your key, use the call to action below.
Endpoint-by-Endpoint Summary with Key Fields
- /api/v1/symbols: Discovery. Filter by category=central_bank and base=USD to find FED_IORB metadata (frequency, currency).
- /api/v1/latest: Latest FED_IORB and dates map. Interpret the value as percent per annum, check dates.FED_IORB for effective date.
- /api/v1/historical: Point-in-time IORB on date=Y-m-d. For daily FED_IORB, it returns the value for that business day if available.
- /api/v1/timeseries: Daily FED_IORB keyed by date over [start, end]. Use frequencies and currencies to validate series assumptions.
- /api/v1/fluctuation: Summary statistics with start_value, end_value, change, change_pct, high, low.
- /api/v1/ohlc: Aggregated open/high/low/close for chosen period (weekly, monthly, quarterly) with data_points per bucket.
- /api/v1/convert: Simple interest cost comparison using latest FED_IORB versus another symbol; returns totals and spreads.
FAQ
How often is FED_IORB updated?
FED_IORB is a daily central bank rate. Expect no changes on weekends or U.S. holidays; the effective date in responses indicates the date the rate applies.
What unit is the value returned in?
Percent per annum. Convert to decimal by dividing by 100 before calculations (e.g., loan interest, spreads in decimal form).
How do I handle missing dates in a time series?
Gaps reflect non-publication days (weekends/holidays). Use the provided dates as the canonical index; avoid forward-filling unless your model requires it.
Can I compute monthly payments using FED_IORB?
Yes. Use the returned annual percentage r to derive r_decimal = r/100 and then your chosen loan formula (interest-only or amortizing). Keep day-count and compounding conventions consistent.
What happens if I exceed my request quota?
The API responds with HTTP 429 and includes Retry-After and X-RateLimit-* headers. Back off and retry after the indicated time, and consider caching frequently requested data.
Ready to ship your integration? Use the official docs on the MCP and get your key here: Register. You can also explore more at interestratesapi.com.