SOFR (SOFR) tracker via Interest Rates API — quality sample 28 Sep 2026

You need reliable, machine-readable SOFR to drive loan pricing, hedging, and risk analytics. By the end of this article, you will query the SOFR symbol (SOFR) from Interest Rates API, read effective dates and units correctly, compute spreads and payment calculations from returned values, and integrate all seven Finance endpoints—symbols, latest, historical, time series, fluctuation, OHLC, and convert—into your production workflow.

SOFR in context: what the symbol represents

SOFR (Secured Overnight Financing Rate) is a USD overnight interbank benchmark. It is designed to reflect the cost of borrowing cash overnight collateralized by U.S. Treasury securities. In Interest Rates API, SOFR is an interbank symbol with a daily frequency. SOFR underpins USD floating-rate loans, securities, and derivatives and is widely required in lending and treasury systems.

For developers, the SOFR symbol code is simply SOFR. All examples below use GET requests against https://interestratesapi.com/api/v1/ with authentication via the api_key query parameter. Do not send authorization headers: append ?api_key=YOUR_KEY to the URL.

Useful links for orientation and docs navigation: Interest Rates API, Register for Interest Rates API, Interest Rates API MCP.

How Interest Rates API expresses SOFR

SOFR values are returned as numeric percentages (e.g., 3.88 means 3.88% annualized). For daily rates, the dates map and/or date fields show the effective calendar date of the rate. If a requested date is a weekend or market holiday, the API may return data for the most recent business day in relevant endpoints per each endpoint’s semantics. When working on dashboards or pipelines, always check the date or the dates map to align effective dates across instruments.

Key points to operationalize:

• Symbol: SOFR
• Category: interbank
• Currency: USD
• Frequency: daily
• Units: percentage points (e.g., 3.88 == 3.88%)
• Authentication: ?api_key=YOUR_KEY query parameter
• HTTP method: GET for all endpoints
• Base URL: https://interestratesapi.com/api/v1/

Production engineering notes:

• Publication cadence: SOFR is daily; expect no new values on non-business days.
• Caching: cache successful latest responses for a few minutes to reduce churn; invalidate on business day boundaries or when your application ticks (e.g., after your job’s daily run).
• Time zone alignment: treat dates as calendar dates—do not assume a specific time-of-day timestamp for daily aggregates.
• Validate symbols and ranges: use /symbols first to confirm availability and metadata before building dashboards.

Quick start: retrieve the latest SOFR

The following latest example uses a real JSON response provided for this article. Copy, paste, and adapt the api_key parameter to run it in your environment.

cURL — latest SOFR

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

JSON (illustrative, real example values provided)

{"success":true,"date":"2026-09-24","base":"USD","rates":{"SOFR":3.88},"dates":{"SOFR":"2026-09-24"},"currencies":{"SOFR":"USD"},"base_filter_note":null}

How to read this:

• success: true means the call succeeded.
• date: “2026-09-24” is the overall batch date for the response.
• rates: a map keyed by symbol. For SOFR, 3.88 means 3.88%.
• dates: per-symbol effective date; dates["SOFR"] shows when the rate applies.
• currencies: per-symbol currency code (USD for SOFR).

Python (requests) — latest SOFR

import requests

url = "https://interestratesapi.com/api/v1/latest"
params = dict(symbols="SOFR", api_key="YOUR_KEY")

resp = requests.get(url, params=params, timeout=15)
resp.raise_for_status()
data = resp.json()

sofr = data["rates"]["SOFR"] # numeric percent, e.g., 3.88
sofr_date = data.get("dates", {}).get("SOFR", data.get("date"))

print(f"SOFR: {sofr}% (effective {sofr_date})")

JavaScript (fetch) — latest SOFR

const response = await fetch(
"https://interestratesapi.com/api/v1/latest?symbols=SOFR&api_key=YOUR_KEY"
);
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
const data = await response.json();
const sofr = data.rates.SOFR;
const sofrDate = (data.dates && data.dates.SOFR) || data.date;
console.log(`SOFR: ${sofr}% (effective ${sofrDate})`);

PHP — latest SOFR

<?php
$endpoint = "https://interestratesapi.com/api/v1/latest?symbols=SOFR&api_key=YOUR_KEY";
$ch = curl_init($endpoint);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$body = curl_exec($ch);
if ($body === false) {
throw new Exception("cURL error: " . curl_error($ch));
}
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode >= 400) {
throw new Exception("HTTP $httpCode: $body");
}

$data = json_decode($body, true);
$sofr = $data["rates"]["SOFR"];
$sofrDate = isset($data["dates"]["SOFR"]) ? $data["dates"]["SOFR"] : $data["date"];
echo "SOFR: {$sofr}% (effective {$sofrDate})\n";

Ready to build against more endpoints? See the MCP and API homepage, or jump straight to the Register link.

Endpoint guide for SOFR

This section covers all seven Finance endpoints with SOFR-focused examples. Every endpoint uses GET and api_key in the query string.

1) /symbols — discover SOFR and related metadata

Use this to confirm symbol availability and attributes. You can filter by category=interbank and base=USD.

cURL

curl "https://interestratesapi.com/api/v1/symbols?category=interbank&base=USD&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"count": 1,
"symbols": [
{
"symbol": "SOFR",
"name": "Secured Overnight Financing Rate",
"category": "interbank",
"country_code": "US",
"currency_code": "USD",
"frequency": "daily",
"description": "USD overnight interbank benchmark"
}
]
}

Python

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/symbols",
params=dict(category="interbank", base="USD", api_key="YOUR_KEY"),
timeout=15
)
symbols = r.json()["symbols"]
print([s["symbol"] for s in symbols])

JavaScript

const res = await fetch("https://interestratesapi.com/api/v1/symbols?category=interbank&base=USD&api_key=YOUR_KEY");
const { symbols } = await res.json();
console.log(symbols.map(s => s.symbol));

PHP

<?php
$url = "https://interestratesapi.com/api/v1/symbols?category=interbank&base=USD&api_key=YOUR_KEY";
$body = file_get_contents($url);
$data = json_decode($body, true);
foreach ($data["symbols"] as $s) {
echo $s["symbol"] . " - " . $s["frequency"] . "\n";
}

2) /latest — current SOFR value

Fetch the latest SOFR value with effective date and currency context.

cURL

curl "https://interestratesapi.com/api/v1/latest?symbols=SOFR&api_key=YOUR_KEY"

JSON (illustrative fields)

{
"success": true,
"date": "2026-09-28",
"base": "USD",
"rates": { "SOFR": 3.88 },
"dates": { "SOFR": "2026-09-24" },
"currencies": { "SOFR": "USD" }
}

Use rates.SOFR for the numeric percent and dates.SOFR as the effective date. The base shows the default or consolidated currency context.

Python

import requests
response = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="SOFR", api_key="YOUR_KEY"),
timeout=15
)
data = response.json()
print(data["rates"]["SOFR"], data.get("dates", {}).get("SOFR", data.get("date")))

JavaScript

const response2 = await fetch("https://interestratesapi.com/api/v1/latest?symbols=SOFR&api_key=YOUR_KEY");
const data2 = await response2.json();
console.log(data2.rates.SOFR, (data2.dates && data2.dates.SOFR) || data2.date);

PHP

<?php
$u = "https://interestratesapi.com/api/v1/latest?symbols=SOFR&api_key=YOUR_KEY";
$d = json_decode(file_get_contents($u), true);
echo $d["rates"]["SOFR"] . " on " . ($d["dates"]["SOFR"] ?? $d["date"]) . "\n";

3) /historical — SOFR on a specific date

Pin a valuation to a loan reset date or backtest checkpoint. Provide a Y-m-d date.

cURL

curl "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=SOFR&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"date": "2025-06-15",
"base": "USD",
"rates": { "SOFR": 5.33 },
"currencies": { "SOFR": "USD" }
}

Python

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

JavaScript

const resH = await fetch("https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=SOFR&api_key=YOUR_KEY");
console.log(await resH.json());

PHP

<?php
$h = "https://interestratesapi.com/api/v1/historical?date=2025-06-15&symbols=SOFR&api_key=YOUR_KEY";
echo file_get_contents($h);

4) /timeseries — SOFR between dates

Pull daily SOFR across an interval to chart or compute rolling statistics.

cURL

curl "https://interestratesapi.com/api/v1/timeseries?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"base": "USD",
"start_date": "2025-09-28",
"end_date": "2026-09-28",
"rates": {
"SOFR": {
"2025-01-02": 5.33,
"2025-01-03": 5.33,
"2025-01-06": 5.33
}
},
"frequencies": { "SOFR": "daily" },
"currencies": { "SOFR": "USD" }
}

Python

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/timeseries",
params=dict(start="2025-09-28", end="2026-09-28", symbols="SOFR", api_key="YOUR_KEY"),
timeout=20
)
series = r.json()["rates"]["SOFR"]
print(list(series.items())[:3])

JavaScript

const ts = await fetch("https://interestratesapi.com/api/v1/timeseries?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY");
const tsData = await ts.json();
console.log(Object.entries(tsData.rates.SOFR).slice(0, 3));

PHP

<?php
$tsUrl = "https://interestratesapi.com/api/v1/timeseries?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY";
$tsData = json_decode(file_get_contents($tsUrl), true);
foreach (array_slice($tsData["rates"]["SOFR"], 0, 3, true) as $d => $v) {
echo "$d = $v\n";
}

5) /fluctuation — SOFR change statistics

Compute a quick period-over-period change with high/low bounds.

cURL

curl "https://interestratesapi.com/api/v1/fluctuation?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"rates": {
"SOFR": {
"start_date": "2025-09-28",
"end_date": "2026-09-28",
"start_value": 5.50,
"end_value": 5.33,
"change": -0.17,
"change_pct": -3.09,
"high": 5.50,
"low": 5.25
}
}
}

Use change for absolute delta in percentage points, and change_pct for the percentage change relative to the start_value.

Python

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/fluctuation",
params=dict(start="2025-09-28", end="2026-09-28", symbols="SOFR", api_key="YOUR_KEY"),
timeout=20
)
fl = r.json()["rates"]["SOFR"]
print(fl["change"], fl["change_pct"], fl["high"], fl["low"])

JavaScript

const flRes = await fetch("https://interestratesapi.com/api/v1/fluctuation?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY");
const flData = await flRes.json();
console.log(flData.rates.SOFR);

PHP

<?php
$flUrl = "https://interestratesapi.com/api/v1/fluctuation?start=2025-09-28&end=2026-09-28&symbols=SOFR&api_key=YOUR_KEY";
$fl = json_decode(file_get_contents($flUrl), true)["rates"]["SOFR"];
echo "Δ=" . $fl["change"] . " (" . $fl["change_pct"] . "%), high=" . $fl["high"] . ", low=" . $fl["low"] . "\n";

6) /ohlc — SOFR OHLC candlesticks

Generate OHLC bars from daily SOFR. Monthly is the default; you can request weekly or quarterly.

cURL

curl "https://interestratesapi.com/api/v1/ohlc?symbols=SOFR&period=monthly&start=2025-09-28&end=2026-09-28&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"period": "monthly",
"start_date": "2025-09-28",
"end_date": "2026-09-28",
"rates": {
"SOFR": [
{
"period": "2025-01",
"open": 5.50,
"high": 5.50,
"low": 5.33,
"close": 5.33,
"data_points": 23
}
]
}
}

data_points counts the daily observations rolled into each OHLC bar.

Python

import requests
r = requests.get(
"https://interestratesapi.com/api/v1/ohlc",
params=dict(symbols="SOFR", period="monthly", start="2025-09-28", end="2026-09-28", api_key="YOUR_KEY"),
timeout=20
)
bars = r.json()["rates"]["SOFR"]
print(bars[0])

JavaScript

const ohlcRes = await fetch("https://interestratesapi.com/api/v1/ohlc?symbols=SOFR&period=monthly&start=2025-09-28&end=2026-09-28&api_key=YOUR_KEY");
const ohlcData = await ohlcRes.json();
console.log(ohlcData.rates.SOFR[0]);

PHP

<?php
$ohlcUrl = "https://interestratesapi.com/api/v1/ohlc?symbols=SOFR&period=monthly&start=2025-09-28&end=2026-09-28&api_key=YOUR_KEY";
$ohlc = json_decode(file_get_contents($ohlcUrl), true)["rates"]["SOFR"];
print_r($ohlc[0]);

7) /convert — compare loan interest cost vs another benchmark

/convert compares the total simple interest cost of an amount over a given term at the latest rate of each symbol. This is useful for quick SOFR vs. policy rate comparisons.

cURL

curl "https://interestratesapi.com/api/v1/convert?from=SOFR&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY"

JSON (illustrative)

{
"success": true,
"amount": 100000,
"term_months": 12,
"from": {
"symbol": "SOFR",
"rate": 5.33,
"date": "2026-09-28",
"total_interest": 5330.00,
"total_payment": 105330.00
},
"to": {
"symbol": "ECB_MRO",
"rate": 4.50,
"date": "2026-09-28",
"total_interest": 4500.00,
"total_payment": 104500.00
},
"difference": {
"rate_spread": 0.83,
"interest_saved": 830.00
}
}

rate_spread is “from.rate - to.rate” in percentage points; total_interest uses a simple-interest assumption per the endpoint.

Python

import requests
c = requests.get(
"https://interestratesapi.com/api/v1/convert",
params=dict(from="SOFR", to="ECB_MRO", amount=100000, term_months=12, api_key="YOUR_KEY"),
timeout=15
).json()
print(c["difference"])

JavaScript

const conv = await fetch("https://interestratesapi.com/api/v1/convert?from=SOFR&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY");
const convData = await conv.json();
console.log(convData.difference);

PHP

<?php
$cv = "https://interestratesapi.com/api/v1/convert?from=SOFR&to=ECB_MRO&amount=100000&term_months=12&api_key=YOUR_KEY";
print_r(json_decode(file_get_contents($cv), true));

Reading and using returned SOFR values

From all endpoints:

• rates map: the numeric percentage you will use in analytics (e.g., 3.88).
• dates map (when present): per-symbol effective date, critical for alignment across instruments.
• currencies map: the ISO currency per symbol (USD for SOFR).
• In fluctuation: start_value, end_value, change, change_pct, high, low.
• In OHLC: open, high, low, close, data_points, and the aggregated period key.

Typical usage patterns:

• Latest snapshot: cache and present SOFR with effective date.
• Historical pin: reconcile accruals on a loan reset date using /historical.
• Charting: use /timeseries and /ohlc for daily lines or monthly bars.
• Quick benchmarking: use /convert to communicate interest cost differences.

Practical implementation details

Publication frequency and business days

SOFR is provided as a daily interbank benchmark. On weekends and relevant market holidays, you should not expect a new value; align your pipelines to fetch on business days, and always check the effective date in the payload. If your front-end shows “as of” dates, use dates["SOFR"] when available.

Caching and refresh strategy

For production pricing or risk screens, fetch the latest SOFR once per cycle and cache for your internal SLA. Suggested approaches:

• Short-term cache (e.g., 1–15 minutes) for /latest during market hours.
• Daily invalidation when your batch jobs run (e.g., after settlement windows).
• Store raw JSON or normalized fields for reproducibility and auditing.

Error handling and rate limits

Common error statuses:

• 401: Missing or invalid api_key.
• 403: Account without active plan.
• 404: No symbols matched or no data for the requested date/range.
• 422: Validation errors (bad symbol or date format).
• 429: Quota exhausted (observe Retry-After and X-RateLimit-* headers).

For resilience:

• Parse success=false payloads and surface error messages.
• Honor Retry-After on 429 and back off requests.
• Validate symbols upfront via /symbols to reduce 404/422 responses.

Computing spreads from SOFR

Spread computation is straightforward:

• Given two rates r1 and r2 (percent), spread_pp = r1 - r2 (percentage points).
• For basis points, spread_bp = (r1 - r2) * 100.

Using the API:

• Get rSOFR = latest SOFR via /latest.
• Get rOther, such as ECB_MRO, via /latest with multiple symbols (e.g., symbols=SOFR,ECB_MRO).
• Compute spread_pp = rSOFR - rOther inside your app.

Computing a monthly payment from SOFR

If you need an amortizing monthly payment from a floating reference like SOFR, you typically add a margin and apply the standard annuity formula. Let r be the annual rate in percent from the API, m be your margin in percent, and P be principal. Convert to a monthly decimal rate i = (r + m) / 100 / 12. Then for an n-month term:

• Payment = P * [ i / (1 - (1 + i)^(-n)) ]

Important: The API returns the benchmark rate only; your pricing may add margin, caps/floors, compounding conventions, and day-counts. Keep your calculations transparent and store the underlying SOFR and effective date for audit.

Pagination and batching

These Finance endpoints return the requested data in one response for the provided range and symbols. There is no separate pagination parameter. If you query long ranges or many symbols, design for streaming JSON processing and timeouts appropriate to your environment.

Data pipelines and backfills

For continuous ingestion:

• Use /latest daily to record the newest SOFR with its date.
• For gaps, /timeseries can backfill a defined window.
• For day-specific corrections, /historical with the exact date ensures idempotent reconciliation.

Use cases that ship with minimal glue code

• Interest rate dashboards: Combine /latest for headline SOFR with /timeseries for historical charts and /ohlc for monthly bars.
• Lending and mortgage tools: Store SOFR and compute borrower payments with a margin. Use /historical to pin resets to specific dates and /fluctuation to summarize recent movements in disclosures.
• Treasury analytics: Produce rolling high/low and change_pct via /fluctuation and monitor spreads to central bank rates using multi-symbol /latest or /convert.
• Risk and macro research: Run backtests using /timeseries; bucket results into OHLC to visualize volatility regimes and compare periods.

Explore more on interestratesapi.com, and keep the MCP guide handy: MCP.

End-to-end example: multi-symbol fetch and spread

Next is a concise pattern to fetch two symbols and compute a spread in your app. This is not a new endpoint—just a synthesis with /latest.

cURL

curl "https://interestratesapi.com/api/v1/latest?symbols=SOFR,ECB_MRO&api_key=YOUR_KEY"

Python

import requests

d = requests.get(
"https://interestratesapi.com/api/v1/latest",
params=dict(symbols="SOFR,ECB_MRO", api_key="YOUR_KEY"),
timeout=15
).json()

r_sofr = d["rates"]["SOFR"]
r_ecb = d["rates"]["ECB_MRO"]
spread_pp = r_sofr - r_ecb
print({"SOFR": r_sofr, "ECB_MRO": r_ecb, "spread_pp": spread_pp})

JavaScript

const res = await fetch("https://interestratesapi.com/api/v1/latest?symbols=SOFR,ECB_MRO&api_key=YOUR_KEY");
const d2 = await res.json();
const spread = d2.rates.SOFR - d2.rates.ECB_MRO;
console.log({ sofr: d2.rates.SOFR, ecb_mro: d2.rates.ECB_MRO, spread_pp: spread });

PHP

<?php
$u = "https://interestratesapi.com/api/v1/latest?symbols=SOFR,ECB_MRO&api_key=YOUR_KEY";
$d = json_decode(file_get_contents($u), true);
$spread = $d["rates"]["SOFR"] - $d["rates"]["ECB_MRO"];
echo "Spread (pp): $spread\n";

Operational guardrails

• Always pass symbols explicitly. The SOFR symbol is SOFR.
• Check dates maps when joining series across symbols; do not assume all series have identical calendars.
• Validate date strings as Y-m-d before calling /historical, /timeseries, /fluctuation, and /ohlc.
• On 429 responses, respect Retry-After. Consult X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset.
• Log success flags and any error fields to accelerate incident response.

Where to go next

Build your first production integration with the snippets above. If you need a key or want to explore more symbols, use: Get started with Interest Rates API, Interest Rates API MCP, and interestratesapi.com.

FAQ

Q1: What does the numeric value of SOFR represent in the API?
A: It is an annualized percentage in percent units. For example, 3.88 means 3.88% per year. Use this value as your base rate when computing spreads or loan payments (after adding your margin if applicable).

Q2: How do I interpret the effective date?
A: Use dates["SOFR"] when present to identify the per-symbol effective date. If that map is not present, fall back to the top-level date. Align your analytics to that effective date.

Q3: Do I need headers for authentication?
A: No. All endpoints are GET and authenticate via the api_key query parameter, for example ?api_key=YOUR_KEY.

Q4: What happens on weekends and holidays?
A: SOFR is daily; expect no new observations on non-business days. For range queries, you may see missing keys on non-business dates. For latest, you’ll receive the most recent available rate with its effective date.

Q5: Can I compare SOFR to central bank policy rates?
A: Yes. Request multiple symbols in /latest (e.g., SOFR,ECB_MRO) or use /convert to see a simple-interest cost comparison. Compute spreads in your code using the returned rates.

If you need an API key to start, use the quick links: Register, or consult the MCP to explore endpoints and symbols in detail.