You need reliable, machine-readable yields for French government bonds to power pricing models, monitor risk, and compute EUR-area spreads. By the end of this guide, you will query France (FR) sovereign yields, build yield curves and timeseries, compute Bund/Treasury spreads, and integrate the data into your own apps using curl, Python, JavaScript, and PHP.
What you can build with France sovereign yields
Bonds-API provides French OAT/BTF yield data as JSON over REST for maturities from bills (1M) to long bonds (30Y and beyond). Typical use cases include:
- Fixed-income dashboards that chart France 2Y/10Y yields and intraday snapshots.
- Portfolio risk and scenario tools that need historical 10Y OAT time series, min/max, and period changes.
- Cross-market analysis of France vs. Bund or Treasury spreads at 10Y.
- Yield curve construction for bootstrapping or macro factor modeling.
All endpoints are HTTP GET on https://bonds-api.com, returning JSON. Yields are expressed in percent (e.g., 4.52 means 4.52%). Spreads are in basis points (bps). Dates are calendar dates in YYYY-MM-DD. Timestamps in responses are UTC.
Explore the service at bonds-api.com and test interactively in the MCP. When you are ready to integrate, get an API key here: Register.
France coverage, maturities, business days, and update cadence
Coverage includes France (ISO2: FR), with maturities that typically span money-market bills (1M, 3M, 6M), short notes (1Y, 2Y), intermediates (5Y, 10Y), and long bonds (30Y). The exact set available at any time is returned by the curve and latest endpoints.
Market days follow Euronext/EU business calendars; there is generally no new official settlement yield on weekends or French market holidays. The API returns the latest known business-day value when markets are closed. Intraday snapshots are timestamped in UTC and reflect market quotes during trading hours.
Cache planning: if you are rendering a public dashboard, cache daily endpoints (latest, curve) for a few minutes to reduce calls. Timeseries endpoints are stable for past dates; you can cache aggressively. Intraday endpoints should be polled at your desired refresh rate and cached briefly to smooth over micro-variations.
Quick note on yields, dates, and spreads
- Yield fields: numeric percent values (e.g., 4.25 means 4.25%).
- Dates: "YYYY-MM-DD" are calendar dates; intraday "fetched_at" is UTC timestamp (ISO 8601).
- Spreads: spread_bps is an integer or decimal in basis points (1 bp = 0.01%).
Endpoint: Latest yields for France
Use this to pull the current yield for specified maturities, or omit maturities to get all available. For France, you can request the 2Y and 10Y simultaneously and render a small overview card in your app.
cURL
curl -s "https://bonds-api.com/api/v1/latest?countries=US&maturities=10Y&api_key=YOUR_API_KEY"Python (requests)
import requests
resp = requests.get(
"https://bonds-api.com/api/v1/latest",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "FR", "maturities": "2Y,10Y"}
)
resp.raise_for_status()
data = resp.json()
fr_2y = data["data"]["FR"]["2Y"]["yield"]
fr_10y = data["data"]["FR"]["10Y"]["yield"]
fr_2y_date = data["data"]["FR"]["2Y"]["date"] # YYYY-MM-DD
fr_10y_date = data["data"]["FR"]["10Y"]["date"]
print("FR 2Y:", fr_2y, "FR 10Y:", fr_10y, "as of", fr_10y_date)JavaScript (fetch)
const url = new URL("https://bonds-api.com/api/v1/latest");
url.search = new URLSearchParams({ countries: "FR", maturities: "2Y,10Y" });
fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
const twoY = json.data.FR["2Y"].yield;
const tenY = json.data.FR["10Y"].yield;
console.log("FR 2Y", twoY, "FR 10Y", tenY, "date", json.data.FR["10Y"].date);
});PHP (file_get_contents)
<?php
$ctx = stream_context_create([
'http' => [
'method' => 'GET',
'header' => "X-API-Key: YOUR_API_KEY\r\n"
]
]);
$url = "https://bonds-api.com/api/v1/latest?countries=FR&maturities=2Y,10Y";
$json = file_get_contents($url, false, $ctx);
$data = json_decode($json, true);
echo "FR 10Y: " . $data["data"]["FR"]["10Y"]["yield"] . " %\n";
?>Official JSON example
{
"success": true,
"date": "2026-10-05",
"rates": {
"US_10Y": 5.256
},
"dates": {
"US_10Y": "2026-10-05"
},
"currencies": {
"US_10Y": "USD"
},
"meta": {
"request_id": "854fe6f9-8146-4bbf-98bd-b062d185bca7",
"timestamp": "2026-10-05T00:05:25+00:00"
}
}Field notes: yields are percentages; the date is the business day; source indicates the data origin. If a requested maturity is unavailable for that day, you will receive an error or that key will be absent.
Endpoint: Historical yield on a specific date (France)
Pin a single-day yield for backtesting or to reconcile a valuation date. If the date is a non-business day, the API may return a 404 if no data exists for that exact date.
cURL
Python
import requests
params = {"country": "FR", "maturity": "10Y", "date": "2025-06-15"}
r = requests.get("https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params)
r.raise_for_status()
h = r.json()
print(h["country"], h["maturity"], h["date"], h["yield"]) # yield in %JavaScript
const params = new URLSearchParams({ country: "FR", maturity: "10Y", date: "2025-06-15" });
fetch("https://bonds-api.com/api/v1/historical?" + params.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(console.log);PHP (Guzzle)
<?php
require 'vendor/autoload.php';
$client = new \GuzzleHttp\Client(['base_uri' => 'https://bonds-api.com/api/v1/']);
$res = $client->get('historical', [
'headers' => ['X-API-Key' => 'YOUR_API_KEY'],
'query' => ['country' => 'FR', 'maturity' => '10Y', 'date' => '2025-06-15']
]);
echo $res->getBody();
?>Official JSON example
Field notes: yield is the percent close/official for that date. Use this to lock down model inputs for historical pricing routines and audit trails.
Endpoint: Timeseries between two dates (France)
Pull a continuous time series for a given maturity. The series includes only dates with available data, generally business days. Use this to chart or compute rolling stats.
cURL
Python
import requests, statistics
p = {"country": "FR", "maturity": "10Y", "start": "2025-10-05", "end": "2026-10-05"}
ts = requests.get("https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"}, params=p).json()
yields = [pt["yield"] for pt in ts["series"]]
print("Observations:", len(yields), "Avg:", sum(yields)/len(yields))JavaScript
const q = new URLSearchParams({ country: "FR", maturity: "10Y", start: "2025-10-05", end: "2026-10-05" });
fetch("https://bonds-api.com/api/v1/timeseries?" + q.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(json => {
const series = json.series;
console.log("First point", series[0]);
});PHP (file_get_contents)
<?php
$ctx = stream_context_create(['http' => ['method' => 'GET', 'header' => "X-API-Key: YOUR_API_KEY\r\n"]]);
$q = http_build_query(['country' => 'FR', 'maturity' => '10Y', 'start' => '2025-10-05', 'end' => '2026-10-05']);
$json = file_get_contents("https://bonds-api.com/api/v1/timeseries?$q", false, $ctx);
echo $json;
?>Official JSON example
Field notes: series is an array of date/yield pairs (percent). Missing non-business days are typical; do not assume equal spacing. Use the date string as your index.
Endpoint: Spread vs. benchmark (France)
Compute the spread between France and a benchmark such as Germany (DE) or the U.S. (US). Spreads are returned in basis points at a given maturity (default 10Y).
cURL
Python
import requests
params = {"country": "FR", "benchmark": "US", "maturity": "10Y"}
sp = requests.get("https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params).json()
print("Spread (bps):", sp["spread_bps"], "FR:", sp["country_yield"], "US:", sp["benchmark_yield"])JavaScript
const spreadParams = new URLSearchParams({ country: "FR", benchmark: "US", maturity: "10Y" });
fetch("https://bonds-api.com/api/v1/spread?" + spreadParams.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(console.log);PHP (Guzzle)
<?php
$client = new \GuzzleHttp\Client(['base_uri' => 'https://bonds-api.com/api/v1/']);
$res = $client->get('spread', [
'headers' => ['X-API-Key' => 'YOUR_API_KEY'],
'query' => ['country' => 'FR', 'benchmark' => 'US', 'maturity' => '10Y']
]);
echo $res->getBody();
?>Official JSON example
Field notes: spread_bps is in basis points. country_yield and benchmark_yield are in percent. Positive spread_bps means France yields are higher than the benchmark.
Endpoint: Full yield curve (France)
Get an entire set of maturities for a single day to draw a curve or bootstrap discount factors. You can also request a specific historical date.
cURL
Python
import requests
curve = requests.get("https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "FR"}).json()
print("Date:", curve["date"], "Inverted:", curve["inverted"])
for mat, y in curve["curve"].items():
print(mat, y)JavaScript
fetch("https://bonds-api.com/api/v1/curve?country=FR", {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(curve => {
console.log("Curve date", curve.date, "inverted", curve.inverted);
Object.entries(curve.curve).forEach(([mat, y]) => console.log(mat, y));
});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=FR", false, $ctx);
?>Official JSON example
Field notes: curve is a mapping from maturity codes to yields in percent. inverted signals whether short maturities exceed long ones, a common recession watch indicator.
Common France maturities returned by curve
| Maturity | Description | Typical use |
|---|---|---|
| 1M, 3M, 6M | Short-term bills (BTF) | Funding rates, carry/roll analysis |
| 1Y, 2Y | Short notes | Rate expectations, policy sensitivity |
| 5Y, 10Y | Benchmark OATs | Risk-free curves, discounting, hedging |
| 30Y | Long OATs | ALM, duration hedges, long-term discounting |
Endpoint: Intraday snapshots (France)
Use this to show day-of quotes for a given date/maturity. Each snapshot includes the UTC timestamp and a source field. Ideal for markets views where traders watch moves throughout the session.
cURL
Python
import requests, datetime
p = {"country": "FR", "maturity": "10Y", "date": "2026-10-05"}
snap = requests.get("https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"}, params=p).json()
for s in snap["snapshots"]:
print(s["fetched_at"], s["yield"], s["source"]) # fetched_at is UTC ISO 8601JavaScript
const qi = new URLSearchParams({ country: "FR", maturity: "10Y", date: "2026-10-05" });
fetch("https://bonds-api.com/api/v1/intraday?" + qi.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(json => {
console.log("Count", json.count, "TZ", json.meta.timezone);
});PHP (Guzzle)
<?php
$client = new \GuzzleHttp\Client(['base_uri' => 'https://bonds-api.com/api/v1/']);
$res = $client->get('intraday', [
'headers' => ['X-API-Key' => 'YOUR_API_KEY'],
'query' => ['country' => 'FR', 'maturity' => '10Y', 'date' => '2026-10-05']
]);
echo $res->getBody();
?>Official JSON example
Field notes: yields are percent; fetched_at is ISO timestamp in UTC. Use count for quick sanity checks and meta.timezone for display.
Endpoint: Fluctuation over a period (France)
Return the start yield, end yield, absolute change, and min/max over a time window for a given maturity. This is useful for summary cards and alerting.
cURL
Python
import requests
params = {"countries": "FR", "maturity": "10Y", "start": "2025-10-05", "end": "2026-10-05"}
fl = requests.get("https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params).json()
fr = fl["data"]["FR"]
print("Δ:", fr["change"], "Min:", fr["min"], "Max:", fr["max"])JavaScript
const qf = new URLSearchParams({ countries: "FR", maturity: "10Y", start: "2025-10-05", end: "2026-10-05" });
fetch("https://bonds-api.com/api/v1/fluctuation?" + qf.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
}).then(r => r.json()).then(console.log);PHP (file_get_contents)
<?php
$ctx = stream_context_create(['http' => ['method' => 'GET', 'header' => "X-API-Key: YOUR_API_KEY\r\n"]]);
$q = http_build_query(['countries' => 'FR', 'maturity' => '10Y', 'start' => '2025-10-05', 'end' => '2026-10-05']);
echo file_get_contents("https://bonds-api.com/api/v1/fluctuation?$q", false, $ctx);
?>Official JSON example
Field notes: all yields are in percent; change is absolute difference in percentage points (not bps). Use this to generate period-over-period summaries.
Building a France yield curve and spreads in your app
1) Curve from multiple maturities
The /curve endpoint returns a ready-to-plot map of maturity to yield for France. If you prefer, you can call /latest with maturities=1M,3M,6M,1Y,2Y,5Y,10Y,30Y to build your own set on the latest business day.
Cache guidance: update the curve every few minutes during trading, and at market close store a daily snapshot for archives.
2) Spread calculations
Use /spread for France vs DE (Bund) or US (Treasury) at 10Y to monitor cross-market risk. The spread_bps field is already normalized to basis points; store it directly for alerts (e.g., threshold breaches).
3) Business days and holidays
Historical and timeseries endpoints return entries for days with data. If you must backfill non-business days, carry forward the most recent yield in your analytics layer, and flag such days to avoid confusing users.
4) Reading timestamps and units
Daily endpoints carry YYYY-MM-DD dates. Intraday snapshots include fetched_at in ISO 8601 UTC. Yields are percent; convert to decimals for internal rate math by dividing by 100 (e.g., 4.52% → 0.0452). Spreads are in bps; convert to percent by dividing by 100 (215 bps → 2.15%).
Error handling and reliability
All endpoints return success=false with an error message on failures. Common status codes:
- 401: Missing or invalid X-API-Key
- 403: Account quota exceeded
- 404: No data for requested country/maturity/date
- 422: Invalid parameter (date format, ISO2)
- 429: Rate limit exceeded
- 500: Server error
Best practices: validate ISO2 codes (FR), check date formats (YYYY-MM-DD), and implement backoff/retry on 429/500 with short jitter. Log both your query parameters and returned error strings for diagnostics.
Official sample block (verbatim)
The following sample is provided verbatim for reference. It uses a US example and includes fields that differ from the France-focused endpoints above.
cURL (official sample)
JSON (official sample)
Putting it together: a France fixed-income module
Here is a minimal plan to wire up a France sovereign dashboard:
- At app start, call /curve?country=FR and render the term structure chart. Store date and inverted flags.
- Poll /latest?countries=FR&maturities=2Y,10Y every few minutes; show a compact card with 2Y vs 10Y.
- For the overview chart, call /timeseries for 10Y over 1 year. For summary stats, also call /fluctuation.
- For cross-market view, call /spread with benchmark=DE or US at 10Y and display spread_bps prominently.
- On the details page, provide /intraday snapshots for the current session with fetched_at timestamps.
Keep JSON parsing defensive: check keys exist, handle missing maturities, and respect UTC when formatting times. For caches, partition by country, maturity, and date.
Sovereign bond primer (France context)
French sovereign bonds include OATs (medium/long-term) and BTFs (short-term bills). The yield reflects the market’s required return and is a function of policy expectations, inflation, growth, and risk premium. The term structure encodes expectations across horizons; an inverted curve (short yields above long) often signals tight monetary policy or growth concerns.
In analytics, use the 10Y France yield as a benchmark for EUR risk-free discounting and as an input to spread models against corporates or other sovereigns. For sensitivities, pair timeseries with spread series to decompose moves into global and idiosyncratic components.
FAQ
Q: What units are yields and spreads in?
Yields are percentages (e.g., 4.52 means 4.52%). Spreads are basis points (bps), where 1 bp = 0.01%.
Q: What timezone are timestamps?
Dates are YYYY-MM-DD without timezone. Intraday fetched_at timestamps are ISO 8601 in UTC. Use meta.timezone if present.
Q: How often should I poll for intraday?
Depends on your UI. Many dashboards use 1–5 minute polling for intraday and 5–10 minute for latest/curve. Use client-side caching to avoid excessive calls.
Q: What happens on weekends and holidays?
You will typically see no new daily data. Use the last available business day for summaries and clearly label dates in your UI.
Q: How do I build a France–Bund spread chart?
Call /spread?country=FR&benchmark=DE&maturity=10Y periodically and store spread_bps alongside France and benchmark yields. For history, combine /timeseries for each country and compute the difference in bps.
Start integrating France sovereign yields today. Explore the docs on bonds-api.com, try live requests in the MCP, and get your API key here: Register.
