Austria Yield Curve

Austria Yield Curve

Analysts tracking Austria’s sovereign curve often need machine-readable yields across maturities, historical observations, and spreads versus benchmarks—delivered reliably to dashboards, risk engines, and research notebooks. By the end of this guide, you’ll be able to query Austria’s latest rates, fetch history and intraday snapshots, compute spreads, and assemble a full AT yield curve from the Bonds API into your own tools.

What you get from this API and how to interpret it

The Bonds API at https://bonds-api.com provides sovereign bond yields as JSON over REST. Yields are returned as percentages (for example, 4.52 means 4.52%), while spreads are returned in basis points (for example, 215 means 2.15%). Dates are ISO 8601 in the format YYYY-MM-DD (for example, 2026-10-29). Intraday timestamps use full ISO 8601 with UTC timezone (for example, 2026-10-29T12:00:00Z) and a meta object indicates timezone where applicable.

Illustration: Austria Yield Curve

Austria (ISO2: AT) coverage includes money-market tenors (for example, 1M, 3M, 6M), short-to-intermediate bonds (for example, 1Y, 2Y, 5Y), and long bonds (for example, 10Y, 30Y). Updates reflect business days; when markets are closed (weekends, Austrian or pan-European holidays), the latest available date remains in effect. The intraday endpoint provides multiple snapshots for a given day and maturity, useful for monitoring moves between the official end-of-day values.

All endpoints are GET requests under the base URL https://bonds-api.com/api/v1/ and require an API key via the X-API-Key header. You can learn more at bonds-api.com and explore models via the MCP. When you are ready to build, use the call to action links at the end of this article to obtain your key.

Latest Austria yields: GET /api/v1/latest

Use this endpoint to fetch the most recent yields for one or multiple maturities. If you omit maturities, the API returns all available maturities for the country.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/latest?countries=AT&maturities=2Y,10Y"

JSON response (official sample)

{
"success": true,
"data": {
"AT": {
"2Y": { "yield": 4.25, "date": "2026-10-29", "source": "official" },
"10Y": { "yield": 4.52, "date": "2026-10-29", "source": "official" }
}
}
}

How to read it:

  • yield: Percentage yield for the maturity (for example, 4.52 means 4.52%).
  • date: Trading date associated with the yield (YYYY-MM-DD).
  • source: The data origin for that quote (for example, official market close).

Python (requests)

import requests

resp = requests.get(
"https://bonds-api.com/api/v1/latest",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"countries": "AT", "maturities": "2Y,10Y"}
)
data = resp.json()
at_2y = data["data"]["AT"]["2Y"]["yield"]
at_10y = data["data"]["AT"]["10Y"]["yield"]
date_2y = data["data"]["AT"]["2Y"]["date"]
print("AT 2Y:", at_2y, "AT 10Y:", at_10y, "Date:", date_2y)

JavaScript (fetch)

const url = new URL("https://bonds-api.com/api/v1/latest");
url.searchParams.set("countries", "AT");
url.searchParams.set("maturities", "2Y,10Y");

fetch(url.toString(), {
method: "GET",
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(json => {
const at2y = json.data.AT["2Y"].yield;
const at10y = json.data.AT["10Y"].yield;
console.log("AT 2Y:", at2y, "AT 10Y:", at10y);
});

PHP (file_get_contents)

<?php
$context = stream_context_create([
"http" => [
"method" => "GET",
"header" => "X-API-Key: YOUR_API_KEY\r\n"
]
]);
$url = "https://bonds-api.com/api/v1/latest?countries=AT&maturities=2Y,10Y";
$json = file_get_contents($url, false, $context);
$data = json_decode($json, true);
echo "AT 10Y: " . $data["data"]["AT"]["10Y"]["yield"] . PHP_EOL;

Historical Austria yield on a specific date: GET /api/v1/historical

Fetch a single historical observation for a given maturity and date. Use this to backfill point-in-time analytics or verify a past signal.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/historical?country=AT&maturity=10Y&date=2025-06-15"

JSON response (official sample)

{
"success": true,
"country": "AT",
"maturity": "10Y",
"date": "2025-06-15",
"yield": 4.38,
"source": "official"
}

Fields:

  • yield: Percentage yield for that instrument on the requested date.
  • date: The requested observation date (YYYY-MM-DD). If the date is a non-business day, a 404 may be returned; query the nearest business day you need.
  • source: Data provenance for auditability.

Python (requests)

import requests

r = requests.get(
"https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "AT", "maturity": "10Y", "date": "2025-06-15"}
)
obs = r.json()
print(obs["maturity"], obs["date"], obs["yield"])

JavaScript (fetch)

const params = new URLSearchParams({
country: "AT",
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(j => console.log(j.maturity, j.date, j.yield));

PHP (file_get_contents)

<?php
$q = http_build_query([
"country" => "AT",
"maturity" => "10Y",
"date" => "2025-06-15"
]);
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
$json = file_get_contents("https://bonds-api.com/api/v1/historical?$q", false, $ctx);
echo $json;

Austria time series: GET /api/v1/timeseries

Retrieve a date-indexed series between two dates, ideal for charting, regressions, or model features. Start and end are inclusive when data exists for those business days.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/timeseries?country=AT&maturity=10Y&start=2025-10-29&end=2026-10-29"

JSON response (official sample)

{
"success": true,
"country": "AT",
"maturity": "10Y",
"series": [
{ "date": "2025-01-02", "yield": 4.21 },
{ "date": "2025-01-03", "yield": 4.19 },
{ "date": "2025-01-06", "yield": 4.23 }
]
}

Each element of series has:

  • date: Business date in YYYY-MM-DD.
  • yield: Percentage yield for that date.

Python (requests)

import requests
p = {"country": "AT", "maturity": "10Y", "start": "2025-10-29", "end": "2026-10-29"}
r = requests.get("https://bonds-api.com/api/v1/timeseries", headers={"X-API-Key": "YOUR_API_KEY"}, params=p)
ts = r.json()["series"]
print("Obs:", len(ts), "First:", ts[0])

JavaScript (fetch)

const q = new URLSearchParams({ country: "AT", maturity: "10Y", start: "2025-10-29", end: "2026-10-29" });
fetch(`https://bonds-api.com/api/v1/timeseries?${q.toString()}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => console.log(`Points: ${j.series.length}`, j.series.slice(0, 3)));

PHP (file_get_contents)

<?php
$params = http_build_query([
"country" => "AT",
"maturity" => "10Y",
"start" => "2025-10-29",
"end" => "2026-10-29"
]);
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
$json = file_get_contents("https://bonds-api.com/api/v1/timeseries?$params", false, $ctx);
$data = json_decode($json, true);
echo count($data["series"]);

Austria vs benchmark spreads: GET /api/v1/spread

Compute the spread in basis points between Austria and a benchmark country for a given maturity (default 10Y). Useful for relative value analysis and risk dashboards.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/spread?country=AT&benchmark=US&maturity=10Y"

JSON response (official sample)

{
"success": true,
"country": "AT",
"benchmark": "US",
"maturity": "10Y",
"spread_bps": 215,
"country_yield": 4.52,
"benchmark_yield": 2.37
}

Fields:

  • spread_bps: Difference in basis points (1 bp = 0.01%). Positive means Austria trades above benchmark.
  • country_yield and benchmark_yield: The underlying yields used for the calculation, in percent.

Python (requests)

import requests
args = {"country": "AT", "benchmark": "US", "maturity": "10Y"}
r = requests.get("https://bonds-api.com/api/v1/spread", headers={"X-API-Key": "YOUR_API_KEY"}, params=args)
s = r.json()
print(f"AT-{s['maturity']} vs {s['benchmark']}: {s['spread_bps']} bps")

JavaScript (fetch)

const qs = new URLSearchParams({ country: "AT", benchmark: "US", maturity: "10Y" });
fetch(`https://bonds-api.com/api/v1/spread?${qs.toString()}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => console.log(`Spread: ${j.spread_bps} bps`));

PHP (file_get_contents)

<?php
$qs = http_build_query(["country" => "AT", "benchmark" => "US", "maturity" => "10Y"]);
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/spread?$qs", false, $ctx);

Full Austria yield curve: GET /api/v1/curve

Retrieve the entire AT curve on the latest available date or a specific date. This is the fastest path to a curve visualization or term-structure model.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/curve?country=AT"

JSON response (official sample)

{
"success": true,
"country": "AT",
"date": "2026-10-29",
"inverted": false,
"curve": {
"1M": 5.31, "3M": 5.27, "6M": 5.18,
"1Y": 4.98, "2Y": 4.25, "5Y": 4.39,
"10Y": 4.52, "30Y": 4.71
}
}

Fields:

  • inverted: Boolean indicating whether shorter maturities yield above longer maturities overall.
  • curve: Key-value map from maturity code (for example, 2Y) to percentage yield.
  • date: The curve observation date in YYYY-MM-DD.

Maturities returned for Austria (example)

MaturityDescriptionUnits
1M, 3M, 6MMoney-market tenorsPercent yield
1Y, 2Y, 5YShort/intermediate bondsPercent yield
10Y, 30YBenchmark long maturitiesPercent yield

Python (requests)

import requests
r = requests.get(
"https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "AT"}
)
curve = r.json()
tenors = ["1M","3M","6M","1Y","2Y","5Y","10Y","30Y"]
points = [(t, curve["curve"].get(t)) for t in tenors]
print("Inverted:", curve["inverted"], "Date:", curve["date"], "Points:", points)

JavaScript (fetch)

const u = new URL("https://bonds-api.com/api/v1/curve");
u.searchParams.set("country", "AT");
fetch(u.toString(), { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(j => {
console.log("Curve date:", j.date, "Inverted:", j.inverted);
console.log(j.curve);
});

PHP (file_get_contents)

<?php
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/curve?country=AT", false, $ctx);

Intraday Austria snapshots: GET /api/v1/intraday

Collect multiple intraday observations for a given date and maturity to monitor market moves between official EOD prints. Timezone in meta is UTC.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/intraday?country=AT&maturity=10Y&date=2026-10-29"

JSON response (official sample)

{
"success": true,
"country": "AT",
"maturity": "10Y",
"date": "2026-10-29",
"snapshots": [
{ "yield": 4.51, "fetched_at": "2026-10-29T09:30:00Z", "source": "market" },
{ "yield": 4.53, "fetched_at": "2026-10-29T12:00:00Z", "source": "market" },
{ "yield": 4.52, "fetched_at": "2026-10-29T15:30:00Z", "source": "market" }
],
"count": 3,
"meta": { "timezone": "UTC" }
}

Fields:

  • snapshots: Array of observations through the day; each yield is in percent.
  • fetched_at: Snapshot timestamp in UTC (ISO 8601).
  • count: Number of snapshots returned.

Python (requests)

import requests
r = requests.get(
"https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "AT", "maturity": "10Y", "date": "2026-10-29"}
)
intraday = r.json()
for s in intraday["snapshots"]:
print(s["fetched_at"], s["yield"])

JavaScript (fetch)

const p = new URLSearchParams({ country: "AT", maturity: "10Y", date: "2026-10-29" });
fetch(`https://bonds-api.com/api/v1/intraday?${p.toString()}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => j.snapshots.forEach(s => console.log(s.fetched_at, s.yield)));

PHP (file_get_contents)

<?php
$qs = http_build_query(["country" => "AT", "maturity" => "10Y", "date" => "2026-10-29"]);
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/intraday?$qs", false, $ctx);

Fluctuation over a period: GET /api/v1/fluctuation

Summarize change, minimum, and maximum yields over a period for one or multiple countries. This is useful for sanity checks, regime detection, or alerting pipelines.

cURL

curl -H "X-API-Key: YOUR_API_KEY" \
"https://bonds-api.com/api/v1/fluctuation?countries=AT&maturity=10Y&start=2025-10-29&end=2026-10-29"

JSON response (official sample)

{
"success": true,
"maturity": "10Y",
"start": "2025-10-29",
"end": "2026-10-29",
"data": {
"AT": {
"start_yield": 4.21,
"end_yield": 4.52,
"change": 0.31,
"min": 3.87,
"max": 4.76
}
}
}

Fields:

  • start_yield and end_yield: Percent yields at the period boundaries.
  • change: End minus start in percent points (for example, 0.31 = +31 bp).
  • min and max: Extremes within the date window, in percent.

Python (requests)

import requests
params = {"countries": "AT", "maturity": "10Y", "start": "2025-10-29", "end": "2026-10-29"}
r = requests.get("https://bonds-api.com/api/v1/fluctuation", headers={"X-API-Key": "YOUR_API_KEY"}, params=params)
f = r.json()["data"]["AT"]
print(f"Δ: {f['change']}pp (min {f['min']}%, max {f['max']}%)")

JavaScript (fetch)

const qp = new URLSearchParams({ countries: "AT", maturity: "10Y", start: "2025-10-29", end: "2026-10-29" });
fetch(`https://bonds-api.com/api/v1/fluctuation?${qp.toString()}`, {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(j => console.log(j.data.AT));

PHP (file_get_contents)

<?php
$q = http_build_query(["countries" => "AT", "maturity" => "10Y", "start" => "2025-10-29", "end" => "2026-10-29"]);
$ctx = stream_context_create(["http" => ["header" => "X-API-Key: YOUR_API_KEY\r\n"]]);
echo file_get_contents("https://bonds-api.com/api/v1/fluctuation?$q", false, $ctx);

Error handling and operational guidance

Handle non-200 responses and parse the JSON error fields consistently. Common errors include:

  • 401: Missing or invalid X-API-Key
  • 403: Account quota exceeded
  • 404: No data for requested country/maturity/date
  • 422: Invalid parameter (for example, badly formatted date)
  • 429: Rate limit exceeded
  • 500: Server error

Operational tips:

  • Business days and holidays: If a requested date is a non-business day for Austria, use the nearest prior business day you require or fall back to /latest or /curve.
  • Caching: For end-of-day endpoints (latest, curve, historical), a daily cache keyed by country and date is safe. For intraday, a short TTL (for example, 1–5 minutes) lets your UI feel fresh without hammering the API.
  • Curve construction: Prefer /curve for a consistent snapshot across maturities on a single date. If you must compose from /latest for multiple maturities, do it within the same fetch to keep timestamps aligned and show the shared date in your UI.
  • Units and rounding: Display yields to 2 or 3 decimals, spreads in basis points (integers). Keep raw values in storage for quantitative work.

Use cases for the Austria curve

Fixed-income dashboards: Plot the AT curve from /curve, overlay the previous month’s curve from /curve?date=YYYY-MM-DD, and show the 2s10s slope (2Y vs 10Y) and inversion flag.

Portfolio risk and hedging: Use /spread against DE or US to track relative value. Trigger alerts on spread_bps breaches sourced from /spread and summarized with /fluctuation for weekly change.

Economic research: Backtest Austria’s macro indicators against 10Y yields from /timeseries. For event studies, pull /intraday snapshots around announcement times to understand immediate market reactions.

Official sample request and response (verbatim)

The following request and response are provided verbatim as an official sample:

curl -s "https://bonds-api.com/api/v1/latest?countries=US&maturities=10Y&api_key=YOUR_API_KEY"
{
"success": true,
"date": "2026-10-29",
"rates": {
"US_10Y": 5.015
},
"dates": {
"US_10Y": "2026-10-29"
},
"currencies": {
"US_10Y": "USD"
},
"meta": {
"request_id": "8b5c6baa-c9b5-4868-b58c-4d52221c6d11",
"timestamp": "2026-10-29T00:06:53+00:00"
}
}

Development checklist for production readiness

  • Authentication: Always send X-API-Key in the request headers.
  • Input validation: Constrain maturity values (for example, 1M, 3M, …, 30Y) and dates as YYYY-MM-DD before requests to avoid 422 errors.
  • Graceful fallbacks: If /intraday is empty early in the day, show the previous snapshot or the prior EOD from /latest.
  • Resilience: Implement brief backoff on 429 and retry idempotent GETs on transient 5xx.
  • Observability: Log success flags and key fields (date, maturity, yield) alongside request parameters for audit trails.

How to build the Austria curve and common spreads

Building a curve snapshot

  • Call /api/v1/curve?country=AT to get a consistent date-stamped curve object.
  • Persist the curve with the date. Display the inverted boolean prominently.
  • Derive slopes: for example, 2s10s = curve["10Y"] - curve["2Y"] in percentage points.

Composing a curve from /latest

  • If you need fewer tenors, use /api/v1/latest?countries=AT&maturities=2Y,5Y,10Y to minimize payload.
  • Verify that all returned maturities share the same date for consistency in analytics.

Spreads and relative value

  • Use /api/v1/spread with benchmark=DE or US for cross-country comparisons at a given maturity.
  • Display spread_bps with sign and color coding; store both country_yield and benchmark_yield for transparency.

End-to-end example: Dashboard snippet

The following example stitches together a practical flow using multiple endpoints for Austria’s 10Y:

  1. Fetch EOD 10Y with /latest for today’s anchor point.
  2. Overlay a 1-year /timeseries for historical trend.
  3. Pull /intraday snapshots for today if your users monitor real-time-ish moves.
  4. Compute a spread against US via /spread for cross-market context.
  5. Summarize the 1-month change using /fluctuation to provide quick deltas.

Security, quotas, and integration hygiene

Never embed your key in client-side code. Route calls via your backend, attach the X-API-Key header server-side, and expose only the data your UI needs. Implement straightforward memoization to reduce duplicate calls during a single request cycle, and cache stable responses like /curve for a defined interval until the next trading day. For active screens that poll /intraday, set a sensible cadence and provide a manual refresh button.

Quick links

  • Register for an API key and start querying Austria’s curve.
  • Explore models at the MCP.
  • Visit bonds-api.com for product details and coverage.

FAQ

How often do Austria yields update?
End-of-day values update on business days. For within-day monitoring, use /intraday to collect multiple snapshots and display the meta.timezone as UTC.

What units should I store?
Store yields as raw decimal percentages (for example, 4.52) and spreads as integers in basis points (for example, 215). Convert only at the presentation layer.

What if I request a date that is a weekend or holiday?
The API may return 404 for that date. Query the nearest business day you require or rely on /latest or /curve to get the most recent observation.

How do I check for a curve inversion?
Use /curve and read the inverted boolean. You can also compute common slopes like 2s10s = curve["10Y"] - curve["2Y"] and 3M10Y = curve["10Y"] - curve["3M"].

Can I request multiple maturities at once?
Yes. Use /latest with a comma-separated maturities list (for example, maturities=2Y,5Y,10Y). For a full, consistent snapshot, /curve is recommended.

Ready to integrate Austria’s sovereign term structure into your workflows? Register for an API key, then explore endpoints and models in the MCP. If you prefer, you can also Register for Bonds API or Get started with Bonds API directly from the site.

Start building with bond data today

Get your API key and access sovereign bond yields across 60+ countries. 7-day free trial, no credit card required.

Related posts

All posts →