You need clean, reliable Australia 10-year government bond yield data that plugs directly into your research notebooks, portfolio tools, or production dashboards. By the end of this guide, you will be able to fetch the latest AU 10Y yield, retrieve historical and intraday values, calculate spreads, and build a full Australian yield curve using the Bonds API over simple GET requests.
What you get from the Bonds API for Australia’s 10Y
Australia’s 10-year sovereign bond is the benchmark for AUD rates and duration risk. With the Bonds API, yields are returned as percentages (e.g., 4.52 means 4.52%). Dates are in ISO Y-m-d format, and intraday timestamps are returned in UTC. You authenticate using an API key via the X-API-Key header, and all endpoints are HTTP GET against the base URL https://bonds-api.com/api/v1/.
In this article we will focus on:
- Fetching the current AU 10Y (and other AU maturities).
- Querying a single past date vs. a date range (time series).
- Comparing AU 10Y vs. a benchmark (e.g., US 10Y) via spreads in basis points.
- Retrieving the full Australian sovereign yield curve.
- Inspecting intraday snapshots and computing period fluctuations.
For documentation and service status, see bonds-api.com. To explore SDKs and tools, visit the MCP. When you’re ready to run requests, you’ll need an API key: Register.
Endpoint: /latest — Current yields for Australia
Use /latest to pull the most recent available yields for Australia. Specify AU in the countries parameter and optionally pass maturities to limit the response to just 10Y (or include others like 2Y).
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-11-20",
"rates": {
"US_10Y": 5.048
},
"dates": {
"US_10Y": "2026-11-20"
},
"currencies": {
"US_10Y": "USD"
},
"meta": {
"request_id": "06ee6e2e-58ef-4e30-af6d-fc43ecaf285b",
"timestamp": "2026-11-20T00:04:06+00:00"
}
}
How to read it:
- yield: Percentage yield (e.g., 4.52 means 4.52%).
- date: The market date (Y-m-d) of the yield observation, typically the latest business day for AU if markets are closed.
- source: The data source tag, 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": "AU", "maturities": "2Y,10Y"},
timeout=10
)
resp.raise_for_status()
data = resp.json()
au10y = data["data"]["AU"]["10Y"]["yield"]
au10y_date = data["data"]["AU"]["10Y"]["date"]
print("AU 10Y:", au10y, "on", au10y_date)
JavaScript (fetch)
async function getLatestAU10Y() {
const url = new URL("https://bonds-api.com/api/v1/latest");
url.searchParams.set("countries", "AU");
url.searchParams.set("maturities", "2Y,10Y");
const res = await fetch(url.toString(), {
method: "GET",
headers: { "X-API-Key": "YOUR_API_KEY" }
});
if (!res.ok) throw new Error("HTTP " + res.status);
const json = await res.json();
const au10y = json.data.AU["10Y"].yield;
const d = json.data.AU["10Y"].date;
console.log("AU 10Y", au10y, "date", d);
}
getLatestAU10Y();
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=AU&maturities=2Y,10Y";
$json = file_get_contents($url, false, $context);
$data = json_decode($json, true);
$au10y = $data["data"]["AU"]["10Y"]["yield"];
$date = $data["data"]["AU"]["10Y"]["date"];
echo "AU 10Y: $au10y on $date\n";
Endpoint: /historical — AU 10Y on a specific date
Use /historical to retrieve the yield for a single date. Useful for point-in-time backfills, testing event windows, or verifying historical snapshots in your database.
cURL
JSON response
Fields:
- country: ISO2 code (AU).
- maturity: Tenor requested (10Y).
- date: Y-m-d for the observation.
- yield: Percentage yield on that date.
- source: Data source label.
Python
import requests
params = {"country": "AU", "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,
timeout=10
)
r.raise_for_status()
print(r.json())
JavaScript
async function getAU10YOnDate(d) {
const url = new URL("https://bonds-api.com/api/v1/historical");
url.searchParams.set("country", "AU");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("date", d);
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
return res.json();
}
getAU10YOnDate("2025-06-15").then(console.log);
PHP
<?php
$params = http_build_query([
"country" => "AU",
"maturity" => "10Y",
"date" => "2025-06-15"
]);
$context = stream_context_create([
"http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]
]);
$url = "https://bonds-api.com/api/v1/historical?$params";
echo file_get_contents($url, false, $context);
Endpoint: /timeseries — AU 10Y between two dates
Use /timeseries for backtests, factor modeling, and visualizing duration risk over time. The response returns a sequence of daily observations for the requested period.
cURL
JSON response
Interpretation:
- series: Array of daily points (business days). Each has date (Y-m-d) and yield (percentage).
Python
import requests
params = {
"country": "AU",
"maturity": "10Y",
"start": "2025-11-20",
"end": "2026-11-20"
}
r = requests.get(
"https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params,
timeout=15
)
r.raise_for_status()
ts = r.json()["series"]
print("First points:", ts[:3])
JavaScript
async function getAUTenYearSeries(start, end) {
const url = new URL("https://bonds-api.com/api/v1/timeseries");
url.searchParams.set("country", "AU");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("start", start);
url.searchParams.set("end", end);
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
return res.json();
}
getAUTenYearSeries("2025-11-20", "2026-11-20").then(console.log);
PHP
<?php
$query = http_build_query([
"country" => "AU",
"maturity" => "10Y",
"start" => "2025-11-20",
"end" => "2026-11-20"
]);
$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/timeseries?$query", false, $ctx);
Endpoint: /spread — AU vs. benchmark spreads
Spreads help you compare Australia’s 10Y to another country’s 10Y (default maturity is 10Y if omitted). The result is in basis points (bps), where 1 bp = 0.01%.
cURL
JSON response
Fields:
- spread_bps: Difference in basis points (bps) between AU and benchmark at the same maturity.
- country_yield, benchmark_yield: Percentage yields used in the calculation.
Python
import requests
params = {"country": "AU", "benchmark": "US", "maturity": "10Y"}
res = requests.get(
"https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params,
timeout=10
)
print(res.json())
JavaScript
async function getAUSpreadVsUS() {
const url = new URL("https://bonds-api.com/api/v1/spread");
url.searchParams.set("country", "AU");
url.searchParams.set("benchmark", "US");
url.searchParams.set("maturity", "10Y");
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
const s = await res.json();
console.log("Spread (bps):", s.spread_bps);
}
getAUSpreadVsUS();
PHP
<?php
$query = http_build_query([
"country" => "AU",
"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?$query", false, $ctx);
Endpoint: /curve — Full Australian yield curve
/curve returns multiple AU maturities in one call, making it ideal for building yield curves, interpolations, and bootstrapping discount factors.
cURL
JSON response
Key fields:
- inverted: Boolean indicating whether the curve is inverted (e.g., short-end above long-end).
- curve: Map of tenor to yield (percent). Use these to draw the yield curve and compute interpolated points.
| Maturity | Example Yield (percent) | Use Case |
|---|---|---|
| 1M–6M | 5.31 to 5.18 | Cash curve, short-rate expectations |
| 1Y–2Y | 4.98 to 4.25 | Policy path, near-term duration |
| 5Y–10Y | 4.39 to 4.52 | Benchmark curve, swap hedges |
| 30Y | 4.71 | Long-duration liability discounting |
Python
import requests
r = requests.get(
"https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "AU"},
timeout=10
)
curve = r.json()["curve"]
au10y = curve["10Y"]
print("Curve points:", curve)
print("AU 10Y from curve:", au10y)
JavaScript
async function getAUCurve() {
const url = new URL("https://bonds-api.com/api/v1/curve");
url.searchParams.set("country", "AU");
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
const json = await res.json();
console.log(json.curve["10Y"]);
}
getAUCurve();
PHP
<?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=AU", false, $ctx);
Endpoint: /intraday — AU 10Y intraday snapshots
Get multiple snapshots during a given UTC date. Useful for monitoring market moves, triggering alerts, or powering streaming dashboards.
cURL
JSON response
Notes:
- snapshots[].yield: Percentage at that timestamp.
- snapshots[].fetched_at: ISO 8601 UTC timestamp (Z suffix means UTC).
- meta.timezone: Use this to align with your application’s clock.
Python
import requests
params = {"country": "AU", "maturity": "10Y", "date": "2026-11-20"}
r = requests.get(
"https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
j = r.json()
print("Snapshots:", j["snapshots"], "Count:", j["count"])
JavaScript
async function getAU10YIntraday(dateStr) {
const url = new URL("https://bonds-api.com/api/v1/intraday");
url.searchParams.set("country", "AU");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("date", dateStr);
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
const json = await res.json();
console.log(json.snapshots.map(s => [s.fetched_at, s.yield]));
}
getAU10YIntraday("2026-11-20");
PHP
<?php
$q = http_build_query([
"country" => "AU",
"maturity" => "10Y",
"date" => "2026-11-20"
]);
$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?$q", false, $ctx);
Endpoint: /fluctuation — AU 10Y change, min, max over a period
Summarize performance over a window: start and end yields, total change, and observed min/max. This is efficient for dashboards and alerting.
cURL
JSON response
Meaning:
- change: End minus start (percentage points, not bps). 0.31 equals +31 bps.
- min/max: Extremes observed during the window.
Python
import requests
params = {
"countries": "AU",
"maturity": "10Y",
"start": "2025-11-20",
"end": "2026-11-20"
}
r = requests.get(
"https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
print(r.json()["data"]["AU"])
JavaScript
async function getAUFluctuation() {
const url = new URL("https://bonds-api.com/api/v1/fluctuation");
url.searchParams.set("countries", "AU");
url.searchParams.set("maturity", "10Y");
url.searchParams.set("start", "2025-11-20");
url.searchParams.set("end", "2026-11-20");
const res = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
if (!res.ok) throw new Error("HTTP " + res.status);
const j = await res.json();
console.log(j.data.AU);
}
getAUFluctuation();
PHP
<?php
$q = http_build_query([
"countries" => "AU",
"maturity" => "10Y",
"start" => "2025-11-20",
"end" => "2026-11-20"
]);
$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);
Practical details for AU 10Y integrations
- Maturities: Common AU tenors include money-market (1M–6M) and bonds out to 30Y. The /curve endpoint returns available points for the query date.
- Business days and holidays: If local markets are closed (e.g., AU public holidays), /latest returns the most recent available trading day. The date field lets you confirm the observation day.
- Update frequency: Latest endpoints reflect market updates as they are published. For higher-frequency monitoring, use /intraday for snapshots within a UTC date.
- Caching: For dashboards refreshing sub-minute, cache /latest for 30–60 seconds. For historical and curve endpoints, daily caching is typically sufficient. Always check the date field and any meta timestamps to determine data staleness.
- Units and timestamps: Yields are percentages. Spreads are in basis points. Historical/time-series dates are Y-m-d. Intraday timestamps are ISO 8601 (UTC).
- Error handling: Check HTTP codes and the JSON error shape: success=false with error explaining 401 (auth), 403 (quota), 404 (no data), 422 (bad params), 429 (rate limit), 500 (server).
To confirm schema updates or new maturities, consult bonds-api.com.
How to build the AU yield curve and derive analytics
Most applications can build the curve with a single /curve call. If you need additional or custom points, you can combine specific maturities via /latest (e.g., 2Y, 5Y, 10Y, 30Y) and then perform interpolation in your code. For cross-country comparison (e.g., AU vs. US), use /spread to compute 10Y spreads in bps; this helps explain relative value and currency hedging costs.
Common downstream tasks:
- Duration and convexity: Use the AU 10Y from /curve or /latest as your benchmark input for shock scenarios.
- Forward rates: Interpolate yields across maturities; fit a spline to the /curve output and derive forwards.
- Event studies: Use /timeseries around RBA meetings to visualize yield reactions; confirm end-of-day values via /historical if you need exact closings.
- Alerting: Use /intraday to trigger notifications on threshold moves (e.g., +8 bps within an hour).
- Performance summaries: Use /fluctuation to show monthly or YTD change, with min/max for context.
Complete, copy-ready error patterns
All endpoints return a consistent error structure on failures:
- 401 Missing or invalid X-API-Key — verify the header.
- 403 Account quota exceeded — reduce frequency or wait.
- 404 No data for requested country/maturity/date — check ISO code (AU), tenor (10Y), and date format (Y-m-d).
- 422 Invalid parameter — correct spelling and formats.
- 429 Rate limit exceeded — apply retry with backoff.
- 500 Server error — retry and monitor.
Sovereign bond fundamentals (AU 10Y)
Australia’s 10-year government bond is the anchor for AUD fixed income. It reflects expectations of the RBA policy rate path, inflation outlook, and risk premium. In analytics workflows, the AU 10Y is used for discount rates, duration hedges, and as the reference point for curve shape analysis. Spreads to US or other benchmarks contextualize macro divergences and currency-adjusted returns.
Quick recipes for developers
Display the AU 10Y on a dashboard
- Call /latest with countries=AU&maturities=10Y.
- Render yield as a percentage with two decimals; show the date to prove freshness.
- Refresh on a schedule and cache briefly to minimize load.
Compute AU 10Y daily change
- Call /timeseries for start and end of your window (e.g., yesterday to today).
- Subtract yields (percentage points), convert to bps if desired (multiply by 100).
Chart the full AU curve
- Call /curve?country=AU for the latest; optionally add date=Y-m-d to pin to a specific day.
- Sort maturities logically (1M, 3M, …, 30Y) and draw a line chart.
FAQ
Q: What units are yields and spreads returned in?
A: Yields are percentages (e.g., 4.52 means 4.52%). Spreads from /spread are in basis points (bps), where 1 bp = 0.01%.
Q: How do I handle non-trading days for Australia?
A: /latest returns the most recent available trading day. Always read the date field to confirm the observation date, particularly around AU public holidays.
Q: Can I fetch multiple AU maturities at once?
A: Yes. Use /latest with maturities as a comma-separated list (e.g., 2Y,5Y,10Y) or use /curve to get the full set for a given date.
Q: What timezone are intraday timestamps in?
A: Intraday timestamps (fetched_at) are in UTC and formatted as ISO 8601 (e.g., 2026-11-20T12:00:00Z).
Q: How should I cache these endpoints?
A: For /latest and /spread, short caching (30–60 seconds) is typical. For /curve, /historical, and /timeseries, daily or per-query caching is common. For /intraday, consider per-minute caching if you poll frequently.
Build your AU 10Y integration now. Explore the reference at bonds-api.com, test endpoints using the MCP, and Register to get your API key and ship a reliable AU 10Y feed to production.