Japan 10 Year Bond Yield

Japan 10 Year Bond Yield

You need accurate, developer-friendly access to the Japan 10-year government bond (JGB) yield to power dashboards, quant models, and risk tools. By the end of this article, you will be able to fetch the latest Japan 10Y yield, query specific historical dates, stream time series and intraday snapshots, compute spreads versus benchmarks, and build the full Japan yield curve using the Bonds API over simple GET requests.

Why the Japan 10Y yield matters for fixed income and finance engineering

The Japan 10-year government bond is the most-watched point on the JGB curve. It anchors discount rates for Japanese cash flows, shapes duration and convexity of local bond portfolios, and is a key input to cross-market relative value strategies. For developers, it’s a core dataset underpinning pricing engines, VaR systems, and research notebooks.

Illustration: Japan 10 Year Bond Yield

All examples below use Bonds API endpoints at https://bonds-api.com and return JSON you can integrate directly. Yields are expressed in percentage points unless otherwise specified; spreads are returned in basis points. Dates are provided in YYYY-MM-DD format; timestamps are in ISO 8601 with timezone, typically UTC.

Useful links you may want open as you build:

Authentication, HTTP method, and data conventions

Bonds API uses simple GET endpoints under the base URL https://bonds-api.com/api/v1/ and authenticates with an API key supplied via the X-API-Key HTTP header. There are no POST, PUT, or DELETE routes—only GET. All sample requests below are copy-pasteable.

  • Base URL: https://bonds-api.com/api/v1/
  • Header: X-API-Key: YOUR_API_KEY
  • All endpoints: GET only
  • Country code for Japan: JP
  • Yields: percentage points (e.g., 4.52 represents 4.52%)
  • Spreads: basis points (e.g., 215 bps = 2.15%)
  • Dates: Y-m-d, e.g., 2026-11-18
  • Timestamps: ISO 8601, UTC where specified (e.g., fetched_at from intraday)

Market data reflects business days. If a requested date is a Japan market holiday or weekend, use the time series or fluctuation endpoints to identify the most recent business day. You can also use the curve endpoint with an optional date to align to a specific session.

Current yields for Japan: /latest

Use this endpoint to fetch the most recent yield prints for Japan across one or multiple maturities. If you omit the maturities parameter, the API returns all available points on the curve for JP.

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': 'JP', 'maturities': '2Y,10Y'}
)
data = resp.json()
# Access yields (percent) and dates by country/maturity
jp_10y_yield = data['data']['JP']['10Y']['yield']
jp_10y_date = data['data']['JP']['10Y']['date']
print(jp_10y_yield, jp_10y_date)

JavaScript (fetch)

const url = new URL('https://bonds-api.com/api/v1/latest');
url.searchParams.set('countries', 'JP');
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 y = json.data.JP['10Y'].yield; // percent
const d = json.data.JP['10Y'].date; // YYYY-MM-DD
console.log('JP 10Y:', y, 'on', d);
});

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=JP&maturities=2Y,10Y';
$json = file_get_contents($url, false, $context);
$data = json_decode($json, true);

$jp10 = $data['data']['JP']['10Y']['yield'];
$date = $data['data']['JP']['10Y']['date'];
echo "JP 10Y: $jp10 on $date\n";

JSON response (fields)

{
    "success": true,
    "date": "2026-11-18",
    "rates": {
        "US_10Y": 5.129
    },
    "dates": {
        "US_10Y": "2026-11-18"
    },
    "currencies": {
        "US_10Y": "USD"
    },
    "meta": {
        "request_id": "b16ab4cc-c6b4-4814-8926-1ab21bd3011e",
        "timestamp": "2026-11-18T00:04:04+00:00"
    }
}

How to read:

  • yield: percentage points (e.g., 4.52 means 4.52%)
  • date: market date for the observation (YYYY-MM-DD), typically latest business day
  • source: origin of the figure (e.g., official)

Official sample block

The following official sample illustrates a latest request and response format. You can run it to validate connectivity and JSON parsing in your app.

Yield on a specific date: /historical

Retrieve the Japan 10Y yield for a precise historical date (business day). If the exact date is a holiday/weekend, check around that date with /timeseries.

cURL

Python (requests)

import requests

params = {'country': 'JP', '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)
hist = r.json()
print(hist['yield'], hist['date'])

JavaScript (fetch)

const params = new URLSearchParams({ country: 'JP', 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(data => {
console.log('JP 10Y on', data.date, 'was', data.yield, '%');
});

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/historical?country=JP&maturity=10Y&date=2025-06-15';
$raw = file_get_contents($url, false, $ctx);
$data = json_decode($raw, true);
echo "Yield: {$data['yield']}% on {$data['date']}\n";

JSON response

Fields:

  • yield: percentage points on the specified date
  • country, maturity: echo parameters
  • source: origin of the data point

Time series for Japan 10Y: /timeseries

Request a daily series for the Japan 10Y between two dates inclusive. Use this for plotting, regressions, and calculating rolling metrics.

cURL

Python (requests)

import requests

p = {
'country': 'JP',
'maturity': '10Y',
'start': '2025-11-18',
'end': '2026-11-18'
}
res = requests.get('https://bonds-api.com/api/v1/timeseries',
headers={'X-API-Key': 'YOUR_API_KEY'},
params=p).json()
series = res['series'] # list of {date, yield}
# Example: compute average
avg = sum(x['yield'] for x in series) / len(series)
print('Avg JP 10Y:', avg)

JavaScript (fetch)

const q = new URLSearchParams({
country: 'JP',
maturity: '10Y',
start: '2025-11-18',
end: '2026-11-18'
});

fetch('https://bonds-api.com/api/v1/timeseries?' + q.toString(), {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
})
.then(r => r.json())
.then(({ series }) => {
const last = series[series.length - 1];
console.log('Observations:', series.length, 'Last:', last.date, last.yield);
});

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/timeseries?country=JP&maturity=10Y&start=2025-11-18&end=2026-11-18';
$data = json_decode(file_get_contents($url, false, $ctx), true);
$series = $data['series'];
echo "First: {$series[0]['date']} {$series[0]['yield']}%\n";

JSON response

Each element is a business-day observation. If your requested range spans holidays, missing days will simply not appear; do not assume calendar continuity.

Spread versus a benchmark: /spread

Compute the Japan yield spread relative to a benchmark market’s yield at the same maturity. The default maturity is 10Y, but you can specify others.

cURL

Python (requests)

import requests

s = requests.get(
'https://bonds-api.com/api/v1/spread',
headers={'X-API-Key': 'YOUR_API_KEY'},
params={'country': 'JP', 'benchmark': 'US', 'maturity': '10Y'}
).json()

bps = s['spread_bps'] # integer/float, basis points
jp = s['country_yield'] # percent
us = s['benchmark_yield']# percent
print(f"JP-US 10Y spread: {bps} bps (JP {jp}% vs US {us}%)")

JavaScript (fetch)

const sp = new URLSearchParams({ country: 'JP', benchmark: 'US', maturity: '10Y' });

fetch('https://bonds-api.com/api/v1/spread?' + sp.toString(), {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
})
.then(r => r.json())
.then(x => {
console.log(`Spread: ${x.spread_bps} bps; JP=${x.country_yield}%, US=${x.benchmark_yield}%`);
});

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/spread?country=JP&benchmark=US&maturity=10Y';
$d = json_decode(file_get_contents($url, false, $ctx), true);
echo "JP-US 10Y: {$d['spread_bps']} bps\n";

JSON response

How to read:

  • spread_bps: JP minus benchmark in basis points
  • country_yield, benchmark_yield: both in percentage points

Full Japan yield curve: /curve

Fetch the complete JGB curve for a given date (or latest available). Use this to build pricing curves, compute forward rates, and visualize term structure.

cURL

Python (requests)

import requests

c = requests.get('https://bonds-api.com/api/v1/curve',
headers={'X-API-Key': 'YOUR_API_KEY'},
params={'country': 'JP'}).json()

curve = c['curve'] # dict keyed by maturities like 1M, 3M, 2Y, 10Y, etc.
print('Date:', c['date'], 'Inverted:', c['inverted'])
print('10Y:', curve.get('10Y'))

JavaScript (fetch)

const qp = new URLSearchParams({ country: 'JP' });

fetch('https://bonds-api.com/api/v1/curve?' + qp.toString(), {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
})
.then(r => r.json())
.then(({ date, inverted, curve }) => {
console.log('Curve date:', date, 'Inverted:', inverted, '10Y:', curve['10Y']);
});

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/curve?country=JP';
$resp = json_decode(file_get_contents($url, false, $ctx), true);
echo "Date: {$resp['date']} Inverted: " . ($resp['inverted'] ? 'true' : 'false') . "\n";
echo "10Y: {$resp['curve']['10Y']}%\n";

JSON response

Fields:

  • curve: maturity-to-yield map in percentage points
  • inverted: boolean indicating whether short rates exceed long rates in aggregate
  • date: market date of the curve

Tip: When building a yield curve object in your app, preserve the maturity keys as strings (e.g., "2Y", "10Y") and sort using tenor-aware logic to avoid lexicographic errors.

Intraday snapshots for Japan 10Y: /intraday

For same-day monitoring and alerting, retrieve multiple snapshots of JP 10Y yields on a single date. Use fetched_at to sequence points and compute intraday changes.

cURL

Python (requests)

import requests
from datetime import datetime

r = requests.get(
'https://bonds-api.com/api/v1/intraday',
headers={'X-API-Key': 'YOUR_API_KEY'},
params={'country': 'JP', 'maturity': '10Y', 'date': '2026-11-18'}
).json()

snaps = r['snapshots'] # list of {yield, fetched_at, source}
snaps.sort(key=lambda s: s['fetched_at'])
open_y = snaps[0]['yield']
close_y = snaps[-1]['yield']
print('Open/Close intraday:', open_y, close_y)

JavaScript (fetch)

const intr = new URLSearchParams({ country: 'JP', maturity: '10Y', date: '2026-11-18' });

fetch('https://bonds-api.com/api/v1/intraday?' + intr.toString(), {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
})
.then(r => r.json())
.then(({ snapshots, meta }) => {
console.log('Timezone:', meta.timezone, 'Points:', snapshots.length);
snapshots.forEach(s => console.log(s.fetched_at, s.yield));
});

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/intraday?country=JP&maturity=10Y&date=2026-11-18';
$d = json_decode(file_get_contents($url, false, $ctx), true);
echo "Count: {$d['count']} TZ: {$d['meta']['timezone']}\n";

JSON response

How to read:

  • yield: percentage points per snapshot
  • fetched_at: ISO 8601 timestamp in UTC—use for ordering
  • count: total number of snapshots returned

Fluctuation summary over a period: /fluctuation

Summarize changes in JP yields between two dates, including start/end, change, and the min/max observed. This is useful for dashboards and risk reports.

cURL

Python (requests)

import requests

fl = requests.get(
'https://bonds-api.com/api/v1/fluctuation',
headers={'X-API-Key': 'YOUR_API_KEY'},
params={'countries': 'JP', 'maturity': '10Y', 'start': '2025-11-18', 'end': '2026-11-18'}
).json()

row = fl['data']['JP']
print('Δ:', row['change'], 'Start:', row['start_yield'], 'End:', row['end_yield'],
'Min:', row['min'], 'Max:', row['max'])

JavaScript (fetch)

const f = new URLSearchParams({
countries: 'JP',
maturity: '10Y',
start: '2025-11-18',
end: '2026-11-18'
});

fetch('https://bonds-api.com/api/v1/fluctuation?' + f.toString(), {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
})
.then(r => r.json())
.then(x => {
const jp = x.data.JP;
console.log('Change:', jp.change, 'Range:', jp.min, '-', jp.max);
});

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/fluctuation?countries=JP&maturity=10Y&start=2025-11-18&end=2026-11-18';
$resp = json_decode(file_get_contents($url, false, $ctx), true);
$jp = $resp['data']['JP'];
echo "Start: {$jp['start_yield']}, End: {$jp['end_yield']}, Δ: {$jp['change']}\n";

JSON response

All yields are in percentage points; change is end_yield minus start_yield in percentage points. Use this for KPI summaries and alerting.

Practical integration notes: maturities, sessions, caching, and building a Japan yield curve

Data coverage includes maturities from money market tenors (e.g., 1M, 3M, 6M) up through long bonds (e.g., 30Y). For Japan, typical liquid points include 2Y, 5Y, 10Y, and 30Y, along with short bills. The curve endpoint returns all available tenors for the requested session date.

Business days and holidays: JGB data aligns to Japan’s market calendar. On weekends and Japan public holidays, latest endpoints will reference the most recent session. If you request an explicit date with no trading session, use /timeseries to detect the nearest prior business day.

Update frequency: Daily endpoints (/latest, /historical, /timeseries, /curve, /fluctuation) refresh after the relevant market session. Intraday snapshots provide multiple points within a session, returned in UTC timestamps. Always read the date and fetched_at fields in responses to anchor calculations.

Caching: For dashboards, cache /curve and /latest results per country per market date to minimize repeated fetches. For intraday monitoring, set a short TTL (e.g., 1–5 minutes) and deduplicate snapshots by fetched_at. Handle common HTTP errors with exponential backoff:

  • 401: check X-API-Key header
  • 404: verify country/maturity/date combination exists for that date
  • 422: check date format (YYYY-MM-DD) and ISO2 codes
  • 429: rate limit exceeded—backoff and retry

Building a yield curve: If your model expects a specific tenor set, read /curve for JP and map the provided keys (e.g., "1M","3M","6M","1Y","2Y","5Y","10Y","30Y"). When your analytics require intermediate points (e.g., 7Y), apply an interpolation method (linear on yield, or spline if you need smooth derivatives). For cross-market relative value, pair Japan 10Y from /latest or /curve with US 10Y via /spread, then track time-varying spreads using /timeseries and /fluctuation.

Real-world use cases for Japan 10Y data

  • Financial dashboards: show JP 10Y latest, daily change (from /fluctuation), and intraday mini-chart (/intraday).
  • Portfolio risk: compute DV01 exposure using the curve levels (/curve), then run stress scenarios by bumping 10Y ±25 bps.
  • Quant research: regress Japan 10Y against macro factors using /timeseries; evaluate beta to global yields via /spread versus US.
  • Pricing engines: discount local cash flows using the Japan curve; interpolate missing points for intermediate maturities.

If you need a quick way to explore the endpoints while you code, open MCP in a browser. For production keys, visit Register. You can always refer back to bonds-api.com for product-level documentation.

How to build a JP 10Y-centric yield curve and spreads in your app

Steps

  1. Fetch all Japan tenors with /curve to anchor the term structure.
  2. If you need more granular points, interpolate between adjacent maturities (e.g., 5Y and 10Y for a 7Y estimate).
  3. Calculate spot-duration or key-rate duration using your preferred method and the curve levels.
  4. If you compare to the US 10Y, call /spread with benchmark=US to obtain a clean JP-US 10Y spread in basis points.
  5. For monitoring, call /intraday for 10Y to render a same-session sparkline; use /fluctuation to show daily/weekly changes.

To prevent noisy UI updates, debounce intraday refreshes and coalesce snapshots by fetched_at. Persist your curve with its date and inverted flag to annotate when Japan’s term structure turns inverted.

Error handling and reliability considerations

Always handle common error shapes:

  • success=false, error="message" for validation or quota issues
  • HTTP 401: Missing/invalid X-API-Key
  • HTTP 403: Quota exceeded
  • HTTP 404: No data for the requested combination
  • HTTP 422: Invalid parameter (date format, ISO2, maturity)
  • HTTP 429: Rate limit exceeded
  • HTTP 500: Server error—retry with backoff

Set sensible retry logic around transient errors (429, 500). For historical backfills, respect country holidays and rely on /timeseries rather than brute-forcing daily /historical calls on closed sessions.

Field reference and units recap

  • yield: percentage points (e.g., 4.52 for 4.52%)
  • spread_bps: basis points (1 bp = 0.01%)
  • date: YYYY-MM-DD market date
  • fetched_at: ISO 8601 timestamp with timezone (UTC in examples)
  • curve: maturity-tenor keys (e.g., 1M, 3M, 6M, 1Y, 2Y, 5Y, 10Y, 30Y) to yields
  • inverted: boolean indicating curve inversion across key tenors

FAQ

Q: Are all yields returned as percentages or decimals?
A: All yields are returned as percentage points (e.g., 4.52 means 4.52%). Spreads are returned in basis points.

Q: What timezone are intraday timestamps in?
A: Intraday fetched_at timestamps are provided in ISO 8601 with timezone; examples show UTC (e.g., 2026-11-18T12:00:00Z). Always parse as timezone-aware datetimes.

Q: How do I get the full Japan curve for a prior date?
A: Call /curve with country=JP and supply the date parameter in YYYY-MM-DD. The API returns the full curve snapshot for that market date.

Q: What if I request a date on a Japan market holiday?
A: /historical expects an actual market date. If you are not sure, use /timeseries around your target period to identify valid business days, or query the nearest prior business day.

Q: How should I handle rate limit errors in production?
A: Implement exponential backoff and cache per-session results (/curve, /latest). For intraday polling, use modest intervals and deduplicate by fetched_at.

Build your Japan 10Y yield workflows today: fetch the latest JP 10Y, compute JP-US 10Y spreads, and render time series and intraday charts with a few GET requests. Get started with Bonds API and explore endpoints interactively in the Bonds API MCP. For product details, see bonds-api.com.

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 →