CDS Spreads and Hazard Rate Term Structure

Bootstrap average and forward hazard rates from CDS spreads at multiple maturities using the approximation λ̄ = s(T) / (1 − R)

A credit default swap spread \(s(T)\) is approximately equal to the expected loss rate: per unit of time, default happens with intensity \(\bar\lambda\) and costs \((1 - R)\) of face value. This gives the quick formula (Hull 2023, chap. 17):

\[ \bar\lambda(T) \;\approx\; \frac{s(T)}{1 - R} \]

where \(\bar\lambda(T)\) is the average hazard rate over \([0, T]\). With spreads at several maturities we can bootstrap forward hazard rates between knots. For adjacent maturities \(T_i < T_{i+1}\):

\[ \lambda_{[T_i, T_{i+1}]} \;=\; \frac{T_{i+1}\,\bar\lambda(T_{i+1}) - T_i\,\bar\lambda(T_i)}{T_{i+1} - T_i} \]

The cumulative default probability at each maturity follows from the constant-hazard formula \(Q(T) = 1 - e^{-\bar\lambda(T)\,T}\).

Note

Recovery assumption matters. Market convention for senior unsecured corporates is \(R = 40\%\); sovereigns typically use \(R = 25\%\). Two traders looking at the same spread but using different recovery assumptions will infer different hazard rates — a small but real source of model risk when extracting PDs from spreads.

fmt = (x, d) => x === undefined || isNaN(x) ? "N/A" : x.toFixed(d)

pctFmt = (x, d = 2) => (x * 100).toFixed(d) + "%"

bpFmt = (x, d = 1) => (x * 10000).toFixed(d) + " bp"

Inputs

Tip

How to experiment

Start with the upward-sloping default. Observe that the forward hazard rates are higher than the average hazard rates beyond the short end — the term structure is rising. Now drag the 7-year and 10-year spreads below the 5-year (a humped shape seen in distressed names expected to either fail or recover soon): the forward hazard rates turn negative beyond the hump. Negative forward hazard is an arbitrage-style red flag on the market quotes, not a model artefact.

viewof cdsS1 = Inputs.range([0, 0.10], { label: "1-year spread (decimal)", step: 0.0005, value: 0.0050 })

viewof cdsS3 = Inputs.range([0, 0.10], { label: "3-year spread", step: 0.0005, value: 0.0080 })

viewof cdsS5 = Inputs.range([0, 0.10], { label: "5-year spread", step: 0.0005, value: 0.0120 })

viewof cdsS7 = Inputs.range([0, 0.10], { label: "7-year spread", step: 0.0005, value: 0.0160 })

viewof cdsS10 = Inputs.range([0, 0.10], { label: "10-year spread", step: 0.0005, value: 0.0200 })

viewof cdsR = Inputs.range([0.0, 0.90], { label: "Recovery rate R", step: 0.01, value: 0.40 })

cdsKnots = {
  const maturities = [1, 3, 5, 7, 10]
  const spreads = [cdsS1, cdsS3, cdsS5, cdsS7, cdsS10]
  const R = cdsR
  const rows = maturities.map((T, i) => {
    const s = spreads[i]
    const avgL = s / (1 - R)
    const Q = 1 - Math.exp(-avgL * T)
    return { T, spread: s, avgLambda: avgL, Q }
  })
  // Forward hazard rates on segments
  const forwards = []
  let Tprev = 0, prevTL = 0
  for (const r of rows) {
    const TL = r.T * r.avgLambda
    const fwd = (TL - prevTL) / (r.T - Tprev)
    forwards.push({ from: Tprev, to: r.T, forward: fwd })
    prevTL = TL; Tprev = r.T
  }
  return { rows, forwards }
}

cdsCurve = {
  // Piecewise-constant forward hazard rate interpreted between knots;
  // build a dense curve of average hazard rate between 0 and 10 years.
  const kn = cdsKnots.rows
  const data = []
  // Start at t = 0; average hazard at t = 0 is the 1-year average by convention.
  const N = 200
  for (let i = 0; i < N; i++) {
    const t = 0.05 + 10 * i / (N - 1)
    // Linear interpolation of T·λ̄(T) in T, then divide by T
    let TLambda
    if (t <= kn[0].T) TLambda = (t / kn[0].T) * kn[0].T * kn[0].avgLambda
    else {
      let k = 0
      while (k < kn.length - 1 && t > kn[k + 1].T) k++
      if (k === kn.length - 1) TLambda = kn[k].T * kn[k].avgLambda +
        (t - kn[k].T) * cdsKnots.forwards[k].forward
      else {
        const TLk = kn[k].T * kn[k].avgLambda
        const fwd = cdsKnots.forwards[k + 1].forward
        TLambda = TLk + (t - kn[k].T) * fwd
      }
    }
    const avgL = TLambda / t
    const Q = 1 - Math.exp(-TLambda)
    data.push({ t, avgLambda: avgL, Q, TLambda })
  }
  return data
}

Average hazard rate by maturity

{
  const kn = cdsKnots.rows
  const yMax = Math.max(...kn.map(d => d.avgLambda)) * 1.20
  return Plot.plot({
    height: 360, marginLeft: 60, marginRight: 20, marginTop: 24,
    x: { label: "Maturity T (years)", domain: [0, 10.5], grid: true },
    y: { label: "Average hazard rate λ̄(T)", domain: [0, yMax], grid: true, tickFormat: d => (d * 100).toFixed(1) + "%" },
    marks: [
      Plot.ruleY([0]),
      Plot.line(cdsCurve, { x: "t", y: "avgLambda", stroke: "#2f71d5", strokeWidth: 2 }),
      Plot.dot(kn, { x: "T", y: "avgLambda", r: 5, fill: "#2f71d5", stroke: "white", strokeWidth: 2 }),
      Plot.text(kn, {
        x: "T", y: "avgLambda",
        text: d => `${fmt(d.T, 0)}y\n${pctFmt(d.avgLambda, 2)}`,
        dy: -22, fontSize: 10, fill: "#2f71d5", fontWeight: 700, lineAnchor: "bottom"
      }),
      Plot.tip(kn, Plot.pointer({
        x: "T", y: "avgLambda",
        title: d => `Maturity: ${fmt(d.T, 0)} years\nSpread: ${bpFmt(d.spread, 1)}\nλ̄(T): ${pctFmt(d.avgLambda, 3)}\nQ(T): ${pctFmt(d.Q, 3)}`
      }))
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">Average hazard rate implied at each maturity using λ̄(T) = s(T) / (1 − R). The curve between knots is built by linear interpolation of the cumulative integrated hazard T·λ̄(T), which is equivalent to piecewise-constant forward hazard rates. Hover over a knot for the full breakdown.</p>`

Forward hazard rates between knots

{
  const fwd = cdsKnots.forwards
  const bars = fwd.map(f => ({
    xMid: (f.from + f.to) / 2, x1: f.from, x2: f.to,
    forward: f.forward,
    label: `Years ${f.from}–${f.to}`
  }))
  const yVals = bars.map(b => b.forward)
  const yMax = Math.max(0.001, ...yVals) * 1.30
  const yMin = Math.min(0, ...yVals) * 1.30
  return Plot.plot({
    height: 360, marginLeft: 60, marginRight: 20, marginTop: 24,
    x: { label: "Segment (years)", domain: [0, 10.5], grid: true },
    y: { label: "Forward hazard rate", domain: [yMin, yMax], grid: true, tickFormat: d => (d * 100).toFixed(1) + "%" },
    marks: [
      Plot.ruleY([0]),
      Plot.rectY(bars, {
        x1: "x1", x2: "x2", y: "forward",
        fill: d => d.forward < 0 ? "#d62728" : "#e67e22", fillOpacity: 0.7,
        stroke: "white"
      }),
      Plot.text(bars, {
        x: "xMid",
        y: d => Math.max(d.forward, 0),
        text: d => pctFmt(d.forward, 2),
        dy: -8, lineAnchor: "bottom",
        fontSize: 10, fontWeight: 700,
        fill: d => d.forward < 0 ? "#d62728" : "#b25600"
      }),
      Plot.tip(bars, Plot.pointer({
        x: "xMid", y: "forward",
        title: d => `${d.label}\nForward λ: ${pctFmt(d.forward, 3)}`
      }))
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">Forward hazard rates between consecutive knots. Negative values, shown in red, signal that the longer spread is "too low" relative to the shorter one given the recovery assumption — the market is pricing less default risk further out than closer in, a shape typically associated with distressed issuers whose investors expect fast resolution.</p>`

Cumulative default probability Q(T)

{
  const kn = cdsKnots.rows
  const yMax = Math.max(...kn.map(d => d.Q)) * 1.20
  return Plot.plot({
    height: 360, marginLeft: 60, marginRight: 20, marginTop: 24,
    x: { label: "Horizon T (years)", domain: [0, 10.5], grid: true },
    y: { label: "Q(T)", domain: [0, Math.max(yMax, 0.005)], grid: true, tickFormat: d => (d * 100).toFixed(1) + "%" },
    marks: [
      Plot.ruleY([0]),
      Plot.line(cdsCurve, { x: "t", y: "Q", stroke: "#d62728", strokeWidth: 2.5 }),
      Plot.dot(kn, { x: "T", y: "Q", r: 5, fill: "#d62728", stroke: "white", strokeWidth: 2 }),
      Plot.text(kn, {
        x: "T", y: "Q",
        text: d => `${fmt(d.T, 0)}y\n${pctFmt(d.Q, 1)}`,
        dy: -22, fontSize: 10, fill: "#d62728", fontWeight: 700, lineAnchor: "bottom"
      }),
      Plot.tip(kn, Plot.pointer({
        x: "T", y: "Q",
        title: d => `Maturity: ${fmt(d.T, 0)} years\nQ(T): ${pctFmt(d.Q, 3)}\nλ̄(T): ${pctFmt(d.avgLambda, 3)}\nSpread: ${bpFmt(d.spread, 1)}`
      }))
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">Cumulative default probability implied by the fitted hazard curve, Q(T) = 1 − exp(−∫₀ᵀ λ(τ) dτ). Because Q is the integrated hazard, a negative forward segment is required to keep Q monotone even though the average hazard can fall.</p>`

Summary

{
  const rows = cdsKnots.rows
  const fwd = cdsKnots.forwards
  const body = rows.map((r, i) => `<tr>
    <td>${r.T}</td>
    <td>${bpFmt(r.spread, 1)}</td>
    <td>${pctFmt(r.avgLambda, 3)}</td>
    <td>${pctFmt(r.Q, 2)}</td>
    <td>${i === 0 ? "—" : pctFmt(fwd[i].forward, 3)}</td>
  </tr>`).join("")
  return html`<table class="table" style="width:100%;">
<thead><tr>
  <th>T (years)</th>
  <th>CDS spread</th>
  <th>Average λ̄(T)</th>
  <th>Q(T)</th>
  <th>Forward λ on previous segment</th>
</tr></thead>
<tbody>${body}</tbody>
</table>`
}

References

Hull, John. 2023. Risk Management and Financial Institutions. 6th ed. John Wiley & Sons.