You need accurate historical Interest on Reserve Balances (IORB) data for modeling, loan pricing, portfolio analytics, and dashboards. By the end of this guide, you will query multi-year FED_IORB history, handle daily frequency and business-day gaps, compute spreads and payments, render OHLC candlesticks, and build a Python pipeline that exports clean time series using the Interest Rates API.
About FED_IORB and how to read it
FED_IORB is the Interest on Reserve Balances set by the Federal Reserve. In the Interest Rates API, FED_IORB is categorized as a central bank rate with daily frequency and USD currency. Values are returned as percentages (for example, 3.9 represents 3.9% per annum).
Key details when consuming FED_IORB:
- Units: percentage per annum.
- Frequency: daily (business days).
- Effective date: supplied in the response either as the top-level “date” or in symbol-specific “dates” maps. Treat dates as the effective date of the rate for that calendar day.
- Missing days: weekends and US market holidays typically have no new observation. Retain the last known value if your use case requires continuity (for example, daily accrual models).
Explore the product and endpoints: Try Interest Rates API and Explore Interest Rates API features.
Multi-year historical data with /timeseries
The /timeseries endpoint is the most efficient way to pull continuous FED_IORB history across months or years. You provide a start and end date (Y-m-d) and one or more symbols. The API returns a dictionary of date-to-value mappings per symbol, alongside metadata about frequency and currency.
cURL: FED_IORB time series
curl -s "https://interestratesapi.com/api/v1/latest?api_key=YOUR_API_KEY&symbols=FED_IORB"JavaScript (fetch): FED_IORB time series
const url = 'https://interestratesapi.com/api/v1/timeseries?start=2025-10-09&end=2026-10-09&symbols=FED_IORB&api_key=YOUR_API_KEY';
const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();
// Access values: data.rates.FED_IORB is a map of date -> rate
// Example: iterate dates in ascending order
const entries = Object.entries(data.rates.FED_IORB).sort((a,b) => a[0].localeCompare(b[0]));
for (const [date, value] of entries) {
console.log(date, value); // value is percentage per annum
}Python (requests): FED_IORB time series
import requests
params = dict(
start='2025-10-09',
end='2026-10-09',
symbols='FED_IORB',
api_key='YOUR_API_KEY'
)
r = requests.get('https://interestratesapi.com/api/v1/timeseries', params=params)
r.raise_for_status()
data = r.json()
series = data['rates']['FED_IORB'] # dict of "YYYY-MM-DD" -> float
dates = sorted(series.keys())
latest_date = dates[-1]
latest_value = series[latest_date]
print(latest_date, latest_value)PHP: FED_IORB time series
<?php
$base = 'https://interestratesapi.com/api/v1/timeseries';
$query = http_build_query([
'start' => '2025-10-09',
'end' => '2026-10-09',
'symbols' => 'FED_IORB',
'api_key' => 'YOUR_API_KEY'
]);
$url = $base . '?' . $query;
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$res = curl_exec($ch);
if ($res === false) {
throw new Exception('cURL error: ' . curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($status !== 200) {
throw new Exception("HTTP $status: $res");
}
$data = json_decode($res, true);
$series = $data['rates']['FED_IORB'] ?? [];
foreach ($series as $date => $value) {
echo $date . ' ' . $value . PHP_EOL;
}
?>Sample JSON response (from the API reference)
{
"success": true,
"date": "2026-10-08",
"base": "USD",
"rates": {
"FED_IORB": 3.9
},
"dates": {
"FED_IORB": "2026-10-08"
},
"currencies": {
"FED_IORB": "USD"
},
"base_filter_note": null
}How to read this:
- rates.FED_IORB: date-indexed daily values in percent per annum.
- frequencies.FED_IORB: confirms daily cadence.
- currencies.FED_IORB: USD.
- Gaps between dates typically reflect weekends/holidays; no pagination is used for this endpoint.
Latest FED_IORB for quick checks
For sanity checks or dashboards, you may want the current FED_IORB value. Below is the official sample you can copy and run. Authentication always uses the api_key query parameter; all endpoints are GET.
OFFICIAL SAMPLE cURL
OFFICIAL SAMPLE JSON
Field notes:
- rates.FED_IORB is the percentage rate (3.9 means 3.9% per annum).
- date is the response date; dates.FED_IORB provides the effective date for this symbol.
- base is the currency context; for FED_IORB it is USD.
Point-in-time lookup with /historical
Use /historical for single-date queries. If the requested date is a weekend/holiday, the API uses the last day with data according to the specification for monthly symbols; for daily symbols, query the nearest prior business day if needed.
cURL: a specific historical date for FED_IORB
Sample JSON
Interpretation: The effective value returned for the requested date is provided under rates.FED_IORB. The value is a percentage per annum, and currency is USD.
Build OHLC candlesticks for FED_IORB with /ohlc
OHLC is aggregated on the fly from daily observations. It is useful when you want a chart-friendly summary per month, week, or quarter for a central bank rate like FED_IORB.
cURL: monthly OHLC for FED_IORB
Sample JSON
Field notes:
- period is the bucket label (e.g., 2025-01 for January 2025).
- open/high/low/close are computed from daily FED_IORB observations in that bucket.
- data_points counts business-day observations contributing to the OHLC.
Plot OHLC with Chart.js (example)
The snippet below shows how to request OHLC data and build a candlestick visualization. Replace YOUR_API_KEY before running in your app context.
<script type="module">
async function fetchOhlc() {
const url = 'https://interestratesapi.com/api/v1/ohlc?symbols=FED_IORB&period=monthly&start=2025-10-09&end=2026-10-09&api_key=YOUR_API_KEY';
const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const json = await res.json();
return json.rates.FED_IORB.map(row => ({
t: row.period, o: row.open, h: row.high, l: row.low, c: row.close
}));
}
// Example: transform to arrays for a custom chart renderer or a candlestick plugin
fetchOhlc().then(data => {
console.log('FED_IORB monthly OHLC:', data);
// Integrate with your charting library of choice
});
</script>Python data pipeline: fetch → pandas → CSV/Parquet
This end-to-end example downloads a FED_IORB time series, normalizes it into a pandas DataFrame (date, value), checks for missing business days, forward-fills if needed (optional), and exports both CSV and Parquet artifacts for downstream analytics.
import io
import sys
import json
import requests
import pandas as pd
API = 'https://interestratesapi.com/api/v1/timeseries'
PARAMS = dict(
start='2025-10-09',
end='2026-10-09',
symbols='FED_IORB',
api_key='YOUR_API_KEY'
)
# 1) Fetch
resp = requests.get(API, params=PARAMS)
resp.raise_for_status()
payload = resp.json()
if not payload.get('success', False):
raise RuntimeError(f"API error: {payload}")
# 2) Normalize to DataFrame
series = payload['rates']['FED_IORB'] # dict: date -> rate (percent)
df = (
pd.DataFrame(list(series.items()), columns=['date', 'rate_pct'])
.assign(date=lambda d: pd.to_datetime(d['date'], format='%Y-%m-%d'))
.sort_values('date')
.set_index('date')
)
# 3) Optional: align to business-day frequency and forward-fill gaps
# This helps with models requiring a value per business day.
df_b = (
df.asfreq('B') # Business day calendar
.ffill() # forward-fill missing business days
)
# 4) Export
df.to_csv('fed_iorb_raw.csv', index=True)
df_b.to_csv('fed_iorb_businessday.csv', index=True)
df.to_parquet('fed_iorb_raw.parquet', index=True)
df_b.to_parquet('fed_iorb_businessday.parquet', index=True)
print('Rows (raw):', len(df), ' | Rows (business-day):', len(df_b))
print('Latest:', df.index.max().date(), df.iloc[-1]['rate_pct'])Notes:
- rate_pct is the percentage per annum. Multiply by 0.01 if you need a decimal rate.
- Forward-filling is a modeling choice; review your governance before applying fills to policy rate series.
- Use Parquet for columnar analytics engines; CSV for portability.
Compute spreads, fluctuations, and payments
Two useful endpoints help quantify change and compare loan costs.
/fluctuation: change and range over a window
Use this to report period-over-period changes, intraperiod highs/lows, and percent change. Ensure you treat all values as percentages (not decimals).
/convert: compare total interest cost using latest rates
Interpretation:
- The API uses latest rates for a simple-interest comparison over term_months.
- rate_spread equals from.rate − to.rate (in percentage points).
- To compute a monthly payment yourself using a returned annual percentage rate r_pct, convert to decimal r = r_pct/100, then apply your chosen amortization formula for your compounding convention (example: fixed-rate annuity payment with monthly compounding uses P = A·[r_m/(1 − (1 + r_m)^(−n))], where r_m is monthly rate and n months).
Practical details that save time
- Business days only: FED_IORB is daily; expect no entries on weekends/US holidays. Use /timeseries for continuous ranges and implement forward-fill only if your model needs it.
- Caching: Cache stable historical ranges aggressively. Intra-day updates are not implied; check “dates” and “date” fields to detect if a new effective day has been published.
- Time zone: Treat dates as calendar dates (no timestamp field). Use UTC-normalized parsing for consistency across systems.
- Units and math: All API values are percentages. Convert to decimals for compounding, accruals, and discounting by dividing by 100.
- OHLC data_points: Use this to gauge completeness of a bucket; major gaps indicate holidays or out-of-range start/end filters.
- Symbol discovery: If needed, you can list USD central bank symbols first, then filter to FED_IORB in your UI.
Discover symbols (optional)
Note: The response above is an example snippet. In practice, filter to the specific symbol “FED_IORB” when building your requests.
Error handling and rate limits
Handle non-200 HTTP codes and check the payload shape on every call. Common responses:
- 401: Missing or invalid api_key.
- 403: Account without active plan.
- 404: No symbols matched or no data in the requested range/date. Some 404s include a details field with available ranges.
- 422: Validation error (for example, wrong date format).
- 429: Request quota exhausted. Inspect the Retry-After header and X-RateLimit-* headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset).
Always include the api_key query parameter and use GET for all endpoints. If you are batching, be mindful of 429s and back off using Retry-After.
Worked example: reading effective dates correctly
For dashboards, prefer the symbol-specific effective date in dates.FED_IORB. When pulling multiple symbols (for example, FED_IORB and a treasury rate), each may publish on slightly different calendars, so normalize per-symbol using the dates map to avoid misalignments. When using /timeseries, the keys of the rates.FED_IORB object are the effective dates; do not assume contiguous days—verify and fill as needed per your model.
Security and deployment notes
- Never hardcode secrets in front-end code. Proxy calls via your backend when deploying to the browser.
- For CI/CD, store YOUR_API_KEY as a secret and inject it into environment variables that your job uses to build artifacts.
- Log request URLs without the api_key during debugging to avoid leaking credentials.
Where to go next
FAQ
Q1: What unit is FED_IORB returned in?
A: Percent per annum. Convert to decimal by dividing by 100 before applying interest math.
Q2: How often is FED_IORB updated?
A: It is exposed as daily frequency in the API. Expect business-day observations; weekends and holidays typically have no new value.
Q3: How should I handle missing dates in /timeseries?
A: Use a business-day index and forward-fill only if your use case requires a value for non-observation days. For analytics that rely on actual publication points, do not fill.
Q4: Which date should my chart show—the top-level date or dates.FED_IORB?
A: Use dates.FED_IORB for the symbol’s effective date when present. For multi-symbol requests, align per symbol.
Q5: Can I compare FED_IORB to another benchmark quickly?
A: Yes. Use /latest for a quick spread (difference in percentage points), /fluctuation for change over time, or /convert to compare simple loan interest costs at the latest rates.
Build your FED_IORB integration now: Register for an API key, then iterate with the docs at MCP.
