You need reliable, machine-readable Romania government bond yields you can query intraday, compare across maturities, and track fluctuation over time. By the end of this guide, you’ll be able to pull Romania (RO) sovereign yields from multiple endpoints, build a yield curve, compute spreads, and display intraday snapshots in your own dashboards—using copy-pasteable GET requests from bonds-api.com.
What you get from Bonds API for Romania
Bonds API delivers sovereign yields as JSON over HTTPS. You’ll use seven GET endpoints to fetch the latest quotes, a full yield curve, historical points, time series, intraday snapshots, period fluctuations, and benchmark spreads for Romania (ISO2: RO). Authentication is passed with an X-API-Key header, and responses express yields as percentages (for example, 4.52 means 4.52%). Spreads are returned in basis points (1 bp = 0.01%). Timestamps are provided in ISO 8601 with timezones explicitly documented per endpoint.
Learn more at https://bonds-api.com. When you are ready to integrate, use the MCP explorer at MCP and request your key via the Register link.
Romania sovereign bond fundamentals in one paragraph
Romania’s sovereign bond yields reflect market expectations of policy rates, inflation, and credit risk for the Romanian state across short bills (e.g., 1M, 3M) through long bonds (e.g., 10Y, 30Y). Short tenors are rate-sensitive, while long tenors encode growth and inflation term premia. Yield curves help you visualize this term structure. For cross-market context, you can compute spreads versus a benchmark (e.g., US Treasuries or German Bunds) in basis points.
Practical notes: maturities, business days, updates, and caching
- Maturities: Romania coverage commonly spans money-market bills (1M–6M), short notes (1Y–5Y), benchmarks (10Y), and sometimes ultra-long (30Y). Use the curve endpoint to see what’s available for a given date.
- Business days and holidays: Yields generally update on business days. On Romanian or global market holidays, the latest date can remain unchanged; time series will skip non-business days.
- Update frequency: Latest and curve endpoints provide the most recent available day’s yields. Intraday snapshots show multiple points throughout the day in UTC.
- Caching: Cache time series and historical responses aggressively. For latest and intraday, cache conservatively and validate freshness in your UI (e.g., label “as of YYYY-MM-DD HH:MM UTC”).
- Units: All “yield” fields are in percent. “spread_bps” is in basis points. Dates are YYYY-MM-DD; timestamps are ISO 8601 with timezone (UTC unless meta says otherwise).
Endpoint 1: Latest Romania yields for selected maturities
Use this to pull the most recent daily yields. If you omit maturities, you’ll get all available for Romania.
cURL
curl -s "https://bonds-api.com/api/v1/latest?countries=US&maturities=10Y&api_key=YOUR_API_KEY"JSON response
{
"success": true,
"date": "2026-10-02",
"rates": {
"US_10Y": 5.252
},
"dates": {
"US_10Y": "2026-10-02"
},
"currencies": {
"US_10Y": "USD"
},
"meta": {
"request_id": "b9b70f35-b60a-4bad-851b-da89e4687120",
"timestamp": "2026-10-02T00:04:04+00:00"
}
}Fields you will use: “yield” is percent; “date” is the effective market date for that quote; “source” indicates origin (e.g., “official”).
Python (requests)
import requests
resp = requests.get(
"https://bonds-api.com/api/v1/latest",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "RO", "maturities": "2Y,10Y"}
)
data = resp.json()
ro = data["data"]["RO"]
y2 = ro["2Y"]["yield"]
y10 = ro["10Y"]["yield"]
asof = ro["10Y"]["date"]
print(f"RO 2Y={y2:.2f}%, 10Y={y10:.2f}% (as of {asof})")JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/latest");
url.search = new URLSearchParams({ countries: "RO", maturities: "2Y,10Y" });
fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
const ro = json.data.RO;
console.log("RO 2Y", ro["2Y"].yield, "RO 10Y", ro["10Y"].yield, "as of", ro["10Y"].date);
});PHP (file_get_contents)
<?php
$context = stream_context_create([
"http" => [
"method" => "GET",
"header" => "X-API-Key: YOUR_API_KEY\r\n"
]
]);
$q = http_build_query(["countries" => "RO", "maturities" => "2Y,10Y"]);
$json = file_get_contents("https://bonds-api.com/api/v1/latest?$q", false, $context);
$data = json_decode($json, true);
$y2 = $data["data"]["RO"]["2Y"]["yield"];
$y10 = $data["data"]["RO"]["10Y"]["yield"];
echo "RO 2Y=$y2, 10Y=$y10";
?Endpoint 2: Historical Romania yield on a specific date
Pin a yield for an exact calendar day (e.g., for month-end or event studies). If the requested date is a non-business day, expect a 404; adjust to the nearest business day with your own logic.
cURL
JSON response
“yield” is percent. “date” is YYYY-MM-DD for the target observation. Use this endpoint to benchmark performance snapshots or to reconcile risk reports to a specific day.
Python (requests)
import requests
r = requests.get(
"https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "RO", "maturity": "10Y", "date": "2025-06-15"}
)
h = r.json()
print(h["country"], h["maturity"], h["date"], h["yield"])JavaScript (fetch)
const params = new URLSearchParams({ country: "RO", maturity: "10Y", date: "2025-06-15" });
fetch(`https://bonds-api.com/api/v1/historical?${params}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => console.log(j.country, j.maturity, j.date, j.yield));PHP (file_get_contents)
<?php
$p = http_build_query(["country" => "RO", "maturity" => "10Y", "date" => "2025-06-15"]);
$context = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
$res = file_get_contents("https://bonds-api.com/api/v1/historical?$p", false, $context);
echo $res;
?Endpoint 3: Romania yield time series
Fetch a continuous sequence of observations for a given maturity between two dates. The series includes business days with available data; weekends and holidays are omitted.
cURL
JSON response
Each element has “date” (YYYY-MM-DD) and “yield” (percent). Use this feed for charts, rolling-vol computations, or factor models.
Python (requests)
import requests
res = requests.get(
"https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "RO", "maturity": "10Y", "start": "2025-10-02", "end": "2026-10-02"}
)
ts = res.json()["series"]
# Compute simple daily changes:
changes = []
for i in range(1, len(ts)):
dy = ts[i]["yield"] - ts[i-1]["yield"]
changes.append({"date": ts[i]["date"], "delta": dy})
print(changes[:5])JavaScript (fetch)
const qs = new URLSearchParams({
country: "RO",
maturity: "10Y",
start: "2025-10-02",
end: "2026-10-02"
});
fetch(`https://bonds-api.com/api/v1/timeseries?${qs}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(json => {
const series = json.series;
const first = series[0];
const last = series[series.length - 1];
console.log("First", first.date, first.yield, "Last", last.date, last.yield);
});PHP (file_get_contents)
<?php
$params = http_build_query([
"country" => "RO",
"maturity" => "10Y",
"start" => "2025-10-02",
"end" => "2026-10-02"
]);
$ctx = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
$json = file_get_contents("https://bonds-api.com/api/v1/timeseries?$params", false, $ctx);
print($json);
?Endpoint 4: Romania spread versus a benchmark
Calculate RO yield spread to a benchmark sovereign at the same maturity. The output includes both yields and the spread in basis points.
cURL
JSON response
“spread_bps” is basis points: 215 means RO 10Y is 2.15% above the benchmark 10Y. “country_yield” and “benchmark_yield” are in percent. Use this to track relative value or hedging relationships.
Python (requests)
import requests
r = requests.get(
"https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "RO", "benchmark": "US", "maturity": "10Y"}
)
s = r.json()
print(f"Spread {s['country']} vs {s['benchmark']} {s['maturity']}: {s['spread_bps']} bps")JavaScript (fetch)
const p = new URLSearchParams({ country: "RO", benchmark: "US", maturity: "10Y" });
fetch(`https://bonds-api.com/api/v1/spread?${p}`, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => console.log(`RO-10Y vs ${j.benchmark}: ${j.spread_bps} bps`));PHP (file_get_contents)
<?php
$p = http_build_query(["country" => "RO", "benchmark" => "US", "maturity" => "10Y"]);
$ctx = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/spread?$p", false, $ctx);
?Endpoint 5: Full Romania yield curve
Pull a snapshot of all available maturities for a given day. This is ideal for plotting a curve, building interpolators, or computing curve shape metrics. If you omit the date parameter, you’ll get the latest available curve.
cURL
JSON response
“curve” is a map from maturity codes to yields, in percent. “inverted” indicates whether short rates exceed long rates in a simple inversion check. “date” is the curve’s valuation date.
Python (requests)
import requests
r = requests.get(
"https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "RO"}
)
c = r.json()
curve = c["curve"]
tenors = ["1M","3M","6M","1Y","2Y","5Y","10Y","30Y"]
pts = [(t, curve.get(t)) for t in tenors if t in curve]
print("Curve date:", c["date"], "Inverted:", c["inverted"])
print(pts)JavaScript (fetch)
fetch("https://bonds-api.com/api/v1/curve?country=RO", {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => {
console.log("As of", j.date, "Inverted:", j.inverted);
console.table(j.curve);
});PHP (file_get_contents)
<?php
$ctx = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/curve?country=RO", false, $ctx);
?Endpoint 6: Intraday Romania yield snapshots
When you need to chart trading-day volatility or calculate realized intraday ranges, use intraday snapshots. Timestamps are in UTC and indicate when the quote was fetched.
cURL
JSON response
“yield” is percent; “fetched_at” is an ISO 8601 UTC timestamp. “count” gives the number of snapshots for that date. Use this to compute intraday highs/lows or to detect micro-structure in moves.
Python (requests)
import requests
from statistics import mean
r = requests.get(
"https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "RO", "maturity": "10Y", "date": "2026-10-02"}
)
j = r.json()
ys = [s["yield"] for s in j["snapshots"]]
print("Intraday count:", j["count"], "avg:", mean(ys), "min:", min(ys), "max:", max(ys))JavaScript (fetch)
const qp = new URLSearchParams({ country: "RO", maturity: "10Y", date: "2026-10-02" });
fetch(`https://bonds-api.com/api/v1/intraday?${qp}`, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
const ys = j.snapshots.map(s => s.yield);
const min = Math.min(...ys), max = Math.max(...ys);
console.log("UTC snapshots:", j.count, "range:", min, "-", max);
});PHP (file_get_contents)
<?php
$params = http_build_query(["country" => "RO", "maturity" => "10Y", "date" => "2026-10-02"]);
$ctx = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/intraday?$params", false, $ctx);
?Endpoint 7: Fluctuation for Romania over a period
Summarize the yield’s start, end, absolute change, and the observed min/max over a date range. This is useful for monthly reviews and VaR calibration heuristics.
cURL
JSON response
All yields are in percent; “change” is absolute difference in percentage points. Use it for summary tiles (“RO 10Y +31 bps m/m”) or alerting when ranges break thresholds.
Python (requests)
import requests
res = requests.get(
"https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "RO", "maturity": "10Y", "start": "2025-10-02", "end": "2026-10-02"}
)
f = res.json()["data"]["RO"]
print(f"Start {f['start_yield']} End {f['end_yield']} Change {f['change']} pp Min {f['min']} Max {f['max']}")JavaScript (fetch)
const params = new URLSearchParams({
countries: "RO",
maturity: "10Y",
start: "2025-10-02",
end: "2026-10-02"
});
fetch(`https://bonds-api.com/api/v1/fluctuation?${params}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => console.log(j.data.RO));PHP (file_get_contents)
<?php
$q = http_build_query(["countries" => "RO", "maturity" => "10Y", "start" => "2025-10-02", "end" => "2026-10-02"]);
$ctx = stream_context_create(["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/fluctuation?$q", false, $ctx);
?Building a Romania yield curve and spreads in practice
To build a Romania curve: call /curve with country=RO and plot by tenor. If you need custom interpolation or tenors not directly available, combine /latest for specific missing tenors with the /curve payload and interpolate in your app (e.g., cubic spline or Nelson–Siegel fitting). For cross-market context, compute spreads with /spread at a shared tenor, storing both the basis-points output and both absolute yields for auditing.
For intraday dashboards, pair /intraday (to draw the day’s path) with /latest (to show “current” alongside “open” from the day’s first snapshot). For risk metrics, use /timeseries for rolling windows, then compare the last and first points with /fluctuation to confirm min/max extrema rapidly without recomputing locally.
Error handling and robustness
- 401/403: Check X-API-Key header is present and quotas are within limits.
- 404: If you request a date with no data (holiday/weekend), adjust to the most recent business day. For a tenor with no coverage, inspect /curve to learn what exists for RO.
- 422: Validate ISO2 codes and date formats (YYYY-MM-DD). Ensure end ≥ start for ranges.
- 429: Back off and retry with jitter. Cache immutable historical/time series to reduce re-requests.
- 500: Implement retry with exponential backoff and circuit breaking as appropriate.
Developer tips that save time
- Normalize units: Yields are percent, spreads are bps. In UI labels, show both (“4.52% (+7 bps)” when comparing two points).
- Timezone: Intraday fetched_at is UTC. Convert to Europe/Bucharest only for display if your users expect local time, but store UTC internally.
- Cache keys: Include country, maturity, and date in your cache key. For time series, key by the full query string (including start/end).
- Bulk latest: When building multi-country monitors, pass comma-separated ISO2 into /latest (e.g., “RO,PL,HU”) and filter client-side.
Required official sample blocks
The following live-format sample shows a simple GET request and JSON structure. It is provided as-is for quick copy/paste testing.
Use cases for Romania yields
- Financial dashboards: Display RO 2Y/5Y/10Y tiles, intraday 10Y line, and a daily-updated curve with inversion flag.
- Portfolio risk tools: Use /timeseries to estimate duration/convexity impacts via empirical shifts; validate regime shifts with /fluctuation min/max.
- Economic research: Measure monetary transmission via short vs long tenor levels and slopes; use /spread to compare to US or DE benchmarks.
- Automated alerts: Trigger notifications if /intraday 10Y deviates by a threshold from the day’s open or if /fluctuation exceeds a multi-quarter high.
Reading the fields correctly
- yield: Percent value, e.g., 4.52 means 4.52%.
- date: YYYY-MM-DD market date of the observation.
- fetched_at: ISO 8601 timestamp in UTC for intraday snapshots.
- spread_bps: Basis points difference between country and benchmark yields at the maturity requested.
- inverted (curve): Boolean flag indicating whether the short end exceeds longer maturities according to a simple check.
See more at bonds-api.com and explore requests interactively in MCP.
FAQ
Q: How are yields and spreads expressed?
A: “yield” values are in percent (e.g., 4.52 for 4.52%). “spread_bps” is in basis points (1 bp = 0.01%).
Q: What timezone are intraday timestamps in?
A: Intraday “fetched_at” fields are UTC. The meta.timezone field will indicate the timezone (UTC) for the intraday endpoint.
Q: What happens on weekends or Romanian market holidays?
A: Latest and curve endpoints will report the most recent business-day data. Time series omit non-business days. Historical requests for a closed date may return 404—adjust to the nearest prior business day in your app.
Q: Can I request multiple countries at once?
A: Yes, the /latest endpoint supports a comma-separated list in the countries parameter (e.g., “RO,PL,HU”). Aggregate client-side to build regional dashboards.
Q: How should I cache these responses?
A: Cache historical and time series aggressively (they are immutable). Cache latest/curve lightly and refresh based on your UI latency budget. Always label data with its “date” or “fetched_at”.
Ready to integrate Romania bond yields into your stack? Use the interactive explorer in MCP and request your API key here: Register.