You need reliable, developer-friendly access to United Arab Emirates (AE) sovereign bond yields for analytics, dashboards, or backtesting. By the end of this guide, you will be able to query the AE yield curve, fetch current and historical 10Y yields, compute spreads versus a benchmark, and stream intraday snapshots—using the Bonds API over simple GET requests with JSON responses.
Why UAE sovereign yields and how they are represented
The United Arab Emirates issues sovereign securities across short- and long-dated maturities. Yields are fundamental for pricing fixed-income instruments, discounting cash flows, measuring duration/convexity, and building macro indicators. The Bonds API expresses yields as percentages (for example, 4.52 means 4.52%), unless otherwise stated. Spreads are expressed in basis points (bps), where 1 bp = 0.01%.
All date fields use the Y-m-d format (for example, 2026-10-21). Intraday timestamps are ISO 8601 strings with a trailing Z to denote UTC (for example, 2026-10-21T12:00:00Z). Data aligns to business days; if there is an exchange or market holiday, the latest available business day is returned for endpoints that default to “latest.” Intraday snapshots are timestamped in UTC.
Explore the product at bonds-api.com. When you are ready to integrate, use the MCP to inspect requests and responses interactively and verify the fields your application needs.
Authentication, request method, and base URL
All endpoints are GET only and live under https://bonds-api.com/api/v1/. Authenticate with an API key passed in the X-API-Key header:
- Base URL: https://bonds-api.com/api/v1/
- HTTP method: GET
- Authentication: X-API-Key header
Get your key at Register. You can also browse the homepage at bonds-api.com and later return to the MCP for testing.
AE latest yields: real-time endpoints for dashboards
Use GET /latest to fetch current yields for United Arab Emirates across one or more maturities. This is ideal for live tiles and end-of-day valuations. If maturities are omitted, all available maturities are returned for the specified country.
cURL
curl -s "https://bonds-api.com/api/v1/latest?countries=AE&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": "AE", "maturities": "2Y,10Y"}
)
data = resp.json()
ae_2y = data["data"]["AE"]["2Y"]["yield"]
ae_10y = data["data"]["AE"]["10Y"]["yield"]
as_of_10y = data["data"]["AE"]["10Y"]["date"]
print("AE 2Y:", ae_2y, "AE 10Y:", ae_10y, "as of", as_of_10y)JavaScript (fetch)
const url = "https://bonds-api.com/api/v1/latest?countries=AE&maturities=2Y,10Y";
fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(json => {
const ae = json.data.AE;
console.log("AE 2Y", ae["2Y"].yield, "as of", ae["2Y"].date);
console.log("AE 10Y", ae["10Y"].yield, "as of", ae["10Y"].date);
});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=AE&maturities=2Y,10Y";
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);
$ae10 = $data["data"]["AE"]["10Y"];
echo "AE 10Y: {$ae10["yield"]}% as of {$ae10["date"]}\n";JSON response
{
"success": false,
"error": "No data found for the specified parameters.",
"code": "not_found"
}How to read it: yields are in percent. date is Y-m-d for the valuation date (business day). source indicates the data origin (for example, “official”). If you request multiple maturities in one call, you can construct a partial curve or drive spread tiles (e.g., 10Y–2Y) without multiple round trips.
Historical AE yield on a given date
Use GET /historical to fetch the yield for a specific maturity on a single date. This is useful for backfills, valuation checkpoints, or reproducible research queries.
cURL
Python (requests)
import requests
params = {"country": "AE", "maturity": "10Y", "date": "2025-06-15"}
resp = requests.get(
"https://bonds-api.com/api/v1/historical",
headers={"X-API-Key": "YOUR_API_KEY"},
params=params
)
h = resp.json()
print(f'AE {h["maturity"]} on {h["date"]}: {h["yield"]}% (source={h["source"]})')JavaScript (fetch)
const params = new URLSearchParams({ country: "AE", 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(h => console.log(`AE ${h.maturity} on ${h.date}: ${h.yield}% (source=${h.source})`));PHP (file_get_contents)
<?php
$q = http_build_query(["country" => "AE", "maturity" => "10Y", "date" => "2025-06-15"]);
$opts = ["http" => ["method" => "GET", "header" => "X-API-Key: YOUR_API_KEY\r\n"]];
$ctx = stream_context_create($opts);
$json = file_get_contents("https://bonds-api.com/api/v1/historical?$q", false, $ctx);
$h = json_decode($json, true);
echo "AE {$h["maturity"]} on {$h["date"]}: {$h["yield"]}% (source={$h["source"]})\n";JSON response
How to read it: yield is a percentage for the requested maturity and date. If the exact date was a non-business day, the API returns an error; use the /timeseries endpoint with a range to locate the closest business day if needed.
AE time series: daily closes over an interval
Use GET /timeseries to fetch daily yields over a start–end range. This is ideal for charting, backtests, rolling volatility, or drawdown analyses. Dates are inclusive and aligned to business days.
cURL
Python (requests)
import requests
import pandas as pd
params = {"country": "AE", "maturity": "10Y", "start": "2025-10-21", "end": "2026-10-21"}
r = requests.get("https://bonds-api.com/api/v1/timeseries",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params)
ts = r.json()
df = pd.DataFrame(ts["series"])
df["date"] = pd.to_datetime(df["date"])
df.set_index("date", inplace=True)
print(df.head())JavaScript (fetch)
const p = new URLSearchParams({
country: "AE",
maturity: "10Y",
start: "2025-10-21",
end: "2026-10-21"
});
fetch("https://bonds-api.com/api/v1/timeseries?" + p.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(ts => {
for (const pt of ts.series) {
console.log(pt.date, pt.yield);
}
});PHP (file_get_contents)
<?php
$params = [
"country" => "AE",
"maturity" => "10Y",
"start" => "2025-10-21",
"end" => "2026-10-21"
];
$q = http_build_query($params);
$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?$q", false, $ctx);
$ts = json_decode($json, true);
foreach ($ts["series"] as $pt) {
echo $pt["date"] . " " . $pt["yield"] . "%\n";
}JSON response
How to read it: series is an array of business-day observations with date (Y-m-d) and yield (percent). Use this to compute rolling stats, regressions, or to build price-implied analytics.
AE vs benchmark spreads (bps)
Use GET /spread to retrieve the current spread between United Arab Emirates and a benchmark country (for example, US Treasuries) for a given maturity. The spread is returned in basis points.
cURL
Python (requests)
import requests
params = {"country": "AE", "benchmark": "US", "maturity": "10Y"}
r = requests.get("https://bonds-api.com/api/v1/spread",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params)
sp = r.json()
print(f'AE-{sp["benchmark"]} {sp["maturity"]} spread: {sp["spread_bps"]} bps '
f'(AE={sp["country_yield"]}%, {sp["benchmark_yield"]}%)')JavaScript (fetch)
const spParams = new URLSearchParams({ country: "AE", benchmark: "US", maturity: "10Y" });
fetch("https://bonds-api.com/api/v1/spread?" + spParams.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(sp => {
console.log(`Spread: ${sp.spread_bps} bps (AE=${sp.country_yield}%, US=${sp.benchmark_yield}%)`);
});PHP (file_get_contents)
<?php
$p = http_build_query(["country" => "AE", "benchmark" => "US", "maturity" => "10Y"]);
$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/spread?$p", false, $ctx);
$sp = json_decode($json, true);
echo "AE vs {$sp["benchmark"]} {$sp["maturity"]} spread: {$sp["spread_bps"]} bps\n";JSON response
How to read it: spread_bps is the difference in basis points (AE yield minus benchmark). country_yield and benchmark_yield are percent. Use this for relative value screens, hedging decisions, and cross-market dashboards.
Full AE yield curve on a date
Use GET /curve to retrieve a full yield curve for AE as of the latest available date, or a specific date. This is the most direct way to build discount curves, spot/forward extractions, or to visualize curve shape (steepening/flattening).
cURL
Python (requests)
import requests
r = requests.get("https://bonds-api.com/api/v1/curve",
headers={"X-API-Key": "YOUR_API_KEY"},
params={"country": "AE"})
curve = r.json()
date = curve["date"]
points = curve["curve"] # dict keyed by maturity like "1M","3M","6M","1Y","2Y",...
is_inverted = curve["inverted"]
print("AE curve as of", date, "inverted?" , is_inverted)
for mat, y in points.items():
print(mat, y)JavaScript (fetch)
const curveUrl = "https://bonds-api.com/api/v1/curve?country=AE";
fetch(curveUrl, { headers: { "X-API-Key": "YOUR_API_KEY" } })
.then(r => r.json())
.then(c => {
console.log("Curve date:", c.date, "inverted:", c.inverted);
for (const [mat, y] of Object.entries(c.curve)) {
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"]]);
$json = file_get_contents("https://bonds-api.com/api/v1/curve?country=AE", false, $ctx);
$c = json_decode($json, true);
echo "AE curve date: {$c["date"]}, inverted? " . ($c["inverted"] ? "yes" : "no") . "\n";
foreach ($c["curve"] as $mat => $y) {
echo "$mat $y%\n";
}JSON response
How to read it: curve is a maturity-to-yield map (percent). inverted is a boolean flag for whether the curve exhibits inversion. date is the curve’s valuation date (Y-m-d, typically a business day). For partial curves across handpicked tenors, you can also call /latest with multiple maturities.
AE intraday snapshots (UTC timestamps)
Use GET /intraday to access intraday yield snapshots for a specific maturity and date. This is suitable for tick charts, execution analytics, and monitoring midday market conditions. Timestamps are provided in UTC via fetched_at.
cURL
Python (requests)
import requests
from datetime import datetime
params = {"country": "AE", "maturity": "10Y", "date": "2026-10-21"}
r = requests.get("https://bonds-api.com/api/v1/intraday",
headers={"X-API-Key": "YOUR_API_KEY"}, params=params)
itd = r.json()
for snap in itd["snapshots"]:
ts = datetime.fromisoformat(snap["fetched_at"].replace("Z","+00:00"))
print(ts, snap["yield"], snap["source"])JavaScript (fetch)
const intradayParams = new URLSearchParams({ country: "AE", maturity: "10Y", date: "2026-10-21" });
fetch("https://bonds-api.com/api/v1/intraday?" + intradayParams.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(itd => {
console.log("Timezone:", itd.meta.timezone);
for (const s of itd.snapshots) {
console.log(s.fetched_at, s.yield, s.source);
}
});PHP (file_get_contents)
<?php
$q = http_build_query(["country" => "AE", "maturity" => "10Y", "date" => "2026-10-21"]);
$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/intraday?$q", false, $ctx);
$itd = json_decode($json, true);
echo "Timezone: {$itd["meta"]["timezone"]}\n";
foreach ($itd["snapshots"] as $s) {
echo $s["fetched_at"] . " " . $s["yield"] . "% " . $s["source"] . "\n";
}JSON response
How to read it: snapshots is an array of (yield percent, fetched_at UTC, source). count is the number of snapshots for the requested date. Use this to compute intraday moves, VWAP-like midpoints, or to trigger alerts.
AE fluctuations: change, min, max over a window
Use GET /fluctuation to summarize the change, minimum, and maximum yield for AE over a given date range. This is great for periodic risk summaries, compliance checks, or performance notes.
cURL
Python (requests)
import requests
p = {"countries": "AE", "maturity": "10Y", "start": "2025-10-21", "end": "2026-10-21"}
r = requests.get("https://bonds-api.com/api/v1/fluctuation",
headers={"X-API-Key": "YOUR_API_KEY"}, params=p)
fx = r.json()
ae = fx["data"]["AE"]
print("Start:", ae["start_yield"], "End:", ae["end_yield"],
"Change:", ae["change"], "Min:", ae["min"], "Max:", ae["max"])JavaScript (fetch)
const fxParams = new URLSearchParams({
countries: "AE",
maturity: "10Y",
start: "2025-10-21",
end: "2026-10-21"
});
fetch("https://bonds-api.com/api/v1/fluctuation?" + fxParams.toString(), {
headers: { "X-API-Key": "YOUR_API_KEY" }
})
.then(r => r.json())
.then(fx => {
const a = fx.data.AE;
console.log("Δ", a.change, "range", a.min, "to", a.max);
});PHP (file_get_contents)
<?php
$p = http_build_query([
"countries" => "AE", "maturity" => "10Y",
"start" => "2025-10-21", "end" => "2026-10-21"
]);
$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/fluctuation?$p", false, $ctx);
$fx = json_decode($json, true)["data"]["AE"];
echo "Start {$fx["start_yield"]} End {$fx["end_yield"]} Δ {$fx["change"]} Min {$fx["min"]} Max {$fx["max"]}\n";JSON response
How to read it: yields are percent. change = end_yield − start_yield (percent). min and max are the extremes within the window. Use it to annotate charts or produce weekly/monthly notes.
Official sample: handling error responses in practice
The API returns structured errors you can log and display. Here is an official sample (copy-pasteable) that intentionally returns a “not found” error. Note that the response includes success=false and a code string you can branch on.
cURL (official sample)
JSON (official sample)
Common error shapes across endpoints include 401 (missing/invalid key), 403 (quota exceeded), 404 (no data for the requested parameters), 422 (invalid parameters), 429 (rate limit exceeded), and 500 (server error). When possible, retry idempotent GETs with backoff on 429/500 and cache successful responses for the day to reduce rate consumption.
Building an AE yield curve and spreads in your app
You have two approaches for the curve:
- Use GET /curve to retrieve the full AE curve as-of a date in one call.
- Use GET /latest with maturities=1M,3M,6M,1Y,2Y,5Y,10Y,30Y to compose a custom subset of points.
To compute curve spreads (for example, 10Y–2Y): fetch both tenors in one /latest call and subtract yields (percent). For cross-country spreads, use GET /spread, which returns spread_bps and both yields explicitly.
Curve points available (example)
| Maturity | What you request |
|---|---|
| 1 month bill | 1M |
| 3 month bill | 3M |
| 6 month bill | 6M |
| 1 year note | 1Y |
| 2 year note | 2Y |
| 5 year note | 5Y |
| 10 year bond | 10Y |
| 30 year bond | 30Y |
Operational details: business days, updates, and caching
- Business days and holidays: If UAE markets are closed, “latest” resolves to the most recent business day. Historical/time series endpoints require valid business-day dates.
- Update frequency: Latest yields and spreads update as new data becomes available; intraday snapshots provide multiple timestamps within a UTC day. For EOD apps, refresh after market close and cache the day’s responses.
- Caching: Cache responses by endpoint, country, maturity, and date. Respect that yields are static for a given business date except for intraday, which changes throughout the day.
- Error handling: Check success. If false, inspect error and code. Handle 404 by falling back to time series to find the nearest available date if needed.
- Security: Always pass your key in the X-API-Key header for production integrations.
End-to-end example: AE 10Y dashboard tile
To build a single 10Y AE tile with a trend chart and a US spread:
- GET /latest with countries=AE&maturities=10Y for the headline yield and date.
- GET /timeseries with country=AE&maturity=10Y for the chart window.
- GET /spread with country=AE&benchmark=US&maturity=10Y for the basis-point spread.
This sequence yields a consistent set of units (percent for yields, bps for spreads) and dates aligned to business days. For a complete curve view, replace step 1 with GET /curve.
Use cases for AE yield history in Finance
- Quant research: regress AE 10Y against oil-sensitive macro factors; compute rolling beta from /timeseries.
- Portfolio risk: track AE 10Y drawdowns and VaR inputs via /fluctuation and daily /timeseries.
- Trading dashboards: intraday monitoring of AE 10Y using /intraday; alert when moves exceed thresholds.
- Cross-market relative value: compute AE–US spreads with /spread for hedged positions.
- Curve analytics: identify steepening/flattening cycles using /curve and 10Y–2Y from /latest.
When you are ready to prototype, the MCP helps you verify queries. For production keys, head to Register. You can also visit bonds-api.com for an overview.
FAQ
What units are yields and spreads in?
Yields are returned as percentages (e.g., 4.52 means 4.52%). Spreads are in basis points (bps), where 100 bps = 1%.
How do I handle non-business days?
Use /timeseries for ranges and align to the returned dates. For single-day calls like /historical, provide a valid business-day date. For “latest,” the API returns the most recent business day with data.
What timezone are intraday timestamps?
Intraday fetched_at timestamps are in UTC and follow ISO 8601 with a trailing Z.
Can I build a yield curve without calling /curve?
Yes. Call /latest with maturities=1M,3M,6M,1Y,2Y,5Y,10Y,30Y and assemble the curve client-side. Use /curve when you want a full, consistent curve and the inversion flag.
How should I cache results?
Cache by (endpoint, country, maturity, date). Daily yields are stable once published; intraday should be cached with short TTLs and keyed by timestamped snapshots if you retain history.
If you need UAE yield history integrated into your stack, you can be live quickly. Test endpoints in the MCP, then Register for an API key and start querying AE yields today.