Basis risk

Basis risk is the uncertainty that remains even after lining up a futures contract to protect a cash-market exposure. A hedge locks in a price on the futures contract, but it does not freeze the spread between the cash market and the futures market. That spread - the basis \(b_t = S_t - F_t\) - is the moving piece that determines how far reality drifts from the hedge you envisioned.

Basis shapes the effective price

When you short a futures contract today, you “lock” the futures price \(F_0\). On the day you offset the hedge, you close your position by buying the futures contract at \(F_T\) and selling your asset on the spot market at \(S_T\).

The total value you receive is the spot price plus the gain or loss from your futures position:

\[\begin{aligned} \text{Effective price} &= S_T + (F_0 - F_T) \\ &= F_0 + (S_T - F_T) \end{aligned}\]

Since the basis on the final day is \(b_T = S_T - F_T\), this simplifies to:

\[ \text{Effective price} = F_0 + b_T. \]

If the basis strengthens (becomes more positive or less negative), the hedge delivers a higher effective price for a short hedger. If it weakens (becomes more negative or less positive), the effective price falls. Managing basis risk is therefore about understanding how that final spread might evolve.

Sources of Basis Risk

Basis risk isn’t just about the unpredictable movement of the spread over time. It arises from any mismatch between the exposure being hedged and the futures contract used. The main sources are:

Asset Mismatch (Cross-Hedging): This is one of the largest sources of basis risk. It occurs when the asset underlying the futures contract is different from the asset being hedged. For example, using crude oil futures to hedge a position in jet fuel. While the prices are correlated, they don’t move in perfect lockstep.
Maturity Mismatch: This occurs if the hedge’s horizon does not match the expiry date of the futures contract. For instance, if you need to hedge an exposure for three months but use a one-month futures contract, you must roll the hedge forward. The basis is unknown for the next contracts, creating risk.
Location Mismatch: The futures contract specifies a particular delivery location (e.g., West Texas Intermediate crude oil delivered in Cushing, Oklahoma). If you are hedging an asset in a different location (e.g., oil in Rotterdam), the local spot price may differ from the price at the delivery hub, creating locational basis risk.

Interactive basis risk lab

The simulation below follows a spot price generated by geometric Brownian motion and derives the associated futures curve under a two-month maturity and a 4% risk-free rate (no dividends). Because the futures contract is written on the same asset as the spot exposure, the basis converges to zero at expiration, so basis risk matters when the hedge is closed out before the delivery date. Choose a preset basis scenario, lock the hedge at any day, then drag the day slider to see how the basis evolves and how the basis on the close-out day determines the effective price.

Tip

How to experiment

Pick a hedge position (Short or Long) and a basis scenario.
Click Resimulate spot path to explore a new trajectory.
Use the slider to choose a day, then press Initiate hedge to lock in the futures price.
If a hedge is active, press Remove hedge to reset it.
Drag the day slider to a close-out day and watch the basis on that day drive the effective price. Notice that the basis shrinks to zero by expiration.

scenarioOptions = [
  { value: "neutral", label: "Neutral basis" },
  { value: "strengthening", label: "Strengthening basis" },
  { value: "weakening", label: "Weakening basis" }
]

viewof hedgeSide = Inputs.radio(["Short", "Long"], {
  label: "Hedge Position",
  value: "Short"
})

viewof scenario = Inputs.radio(scenarioOptions.map(option => option.value), {
  label: "Basis scenario",
  value: "strengthening",
  format: value => scenarioOptions.find(option => option.value === value).label
})

mutable hedgeLocked = false
mutable lockedF = null
mutable hedgeDay = null
mutable resimulateClicks = 0

viewof buttonControls = {
  hedgeLocked; // Depend on this state

  const resimulateButton = html`<button style="background: white; color: #495057; border: 1px solid #adb5bd; border-radius: 6px; padding: 0.3rem 0.8rem; font-weight: 500; font-size: 0.9rem; cursor: pointer;">Resimulate spot path</button>`
  const startHedgeButton = html`<button style="background: #2f71d5; color: white; border: none; border-radius: 6px; padding: 0.3rem 0.8rem; font-weight: 500; font-size: 0.9rem; cursor: pointer;">Initiate hedge</button>`
  const removeHedgeButton = html`<button style="background: white; color: #d00000; border: 1px solid #d00000; border-radius: 6px; padding: 0.3rem 0.8rem; font-weight: 500; font-size: 0.9rem; cursor: pointer;">Remove hedge</button>`

  resimulateButton.onclick = () => {
    mutable hedgeLocked = false
    mutable lockedF = null
    mutable hedgeDay = null
    mutable resimulateClicks += 1
  }

  startHedgeButton.onclick = () => {
    if (!hedgeLocked && simulationPath && simulationPath.length > 0) {
      const day = Math.round(selectedDay)
      mutable hedgeDay = day
      mutable lockedF = simulationPath[day].futures
      mutable hedgeLocked = true
    }
  }

  removeHedgeButton.onclick = () => {
    mutable hedgeLocked = false
    mutable lockedF = null
    mutable hedgeDay = null
  }

  const container = html`<div style="display: flex; gap: 0.5rem; flex-wrap: wrap; align-items: center; margin-bottom: 1rem;"></div>`
  container.append(resimulateButton)

  if (!hedgeLocked) {
    container.append(startHedgeButton)
  } else {
    container.append(removeHedgeButton)
  }

  return container
}

formatCurrency = (value, digits = 2) =>
  new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: "USD",
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  }).format(value)

formatSigned = (value, digits = 2) => {
  const magnitude = Math.abs(value).toFixed(digits)
  return `${value >= 0 ? "+" : "-"}${magnitude}`
}

basisMood = value => {
  const tolerance = 0.05
  if (Math.abs(value) < tolerance) return "steady"
  return value >= 0 ? "strengthening" : "weakening"
}

mulberry32 = seed => {
  return function () {
    let t = seed += 0x6D2B79F5
    t = Math.imul(t ^ t >>> 15, t | 1)
    t ^= t + Math.imul(t ^ t >>> 7, t | 61)
    return ((t ^ t >>> 14) >>> 0) / 4294967296
  }
}

// Standard normal draw (Box-Muller) from a uniform RNG
randomNormal = rng => {
  let u = 0, v = 0
  while (u === 0) u = rng()
  while (v === 0) v = rng()
  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v)
}

baseSeed = 20241105
randomSeed = baseSeed + resimulateClicks

tradingDaysPerYear = 252
hedgeDays = 42
riskFreeRate = 0.04
startSpot = 82
mu = 0.05
sigma = 0.25

basisBump = t => Math.sin(Math.PI * t)

scenarioSettings = new Map([
  ["neutral", { label: "Neutral basis", peakShift: 0 }],
  ["strengthening", { label: "Strengthening basis", peakShift: 1.4 }],
  ["weakening", { label: "Weakening basis", peakShift: -1.4 }]
])

simulationPath = {
  const rng = mulberry32(randomSeed)
  const dt = 1 / tradingDaysPerYear
  const path = []
  let spot = startSpot
  for (let day = 0; day <= hedgeDays; day++) {
    if (day > 0) {
      const drift = (mu - 0.5 * sigma ** 2) * dt
      const diffusion = sigma * Math.sqrt(dt) * randomNormal(rng)
      spot = spot * Math.exp(drift + diffusion)
    }

    const remainingYears = Math.max((hedgeDays - day) / tradingDaysPerYear, 0)
    const fairFutures = spot * Math.exp(riskFreeRate * remainingYears)
    const fairBasis = spot - fairFutures
    const scenarioConfig = scenarioSettings.get(scenario)
    // The shift vanishes at expiry so the basis converges to zero (same-asset hedge)
    const shift = basisBump(day / hedgeDays) * scenarioConfig.peakShift
    const actualBasis = fairBasis + shift
    const futures = spot - actualBasis

    path.push({
      day,
      spot: Number(spot.toFixed(2)),
      futures: Number(futures.toFixed(2)),
      basis: Number(actualBasis.toFixed(2)),
      fairBasis: Number(fairBasis.toFixed(2)),
      shift: Number(shift.toFixed(2)),
      fairFutures: Number(fairFutures.toFixed(2))
    })
  }
  return path
}

viewof selectedDay = {
  simulationPath
  return Inputs.range([0, hedgeDays], {
    label: "Reveal hedge day",
    step: 1,
    value: 0,
    play: true,
    loop: true,
    speed: 0.8
  })
}

visiblePath = simulationPath.filter(point => point.day <= selectedDay)

selectedSnapshot = simulationPath[Math.round(selectedDay)]
finalSnapshot = simulationPath[simulationPath.length - 1]
hedgeActiveOnDay = hedgeLocked && hedgeDay !== null && selectedSnapshot.day >= hedgeDay
effectivePrice = hedgeActiveOnDay ? Number((lockedF + selectedSnapshot.basis).toFixed(2)) : null

chart = Plot.plot({
  height: 340,
  marginLeft: 48,
  marginRight: 24,
  x: {
    label: "Day",
    tickFormat: d => `${d}`
  },
  y: {
    label: "Price (USD)",
    grid: true
  },
  marks: [
    Plot.line(simulationPath, { x: "day", y: "spot", stroke: "#2196F3", strokeOpacity: 0.25, strokeWidth: 1, title: d => `Day ${d.day}: Spot ${formatCurrency(d.spot)}` }),
    Plot.line(simulationPath, { x: "day", y: "futures", stroke: "#ff7f0e", strokeOpacity: 0.25, strokeWidth: 1, title: d => `Day ${d.day}: Futures ${formatCurrency(d.futures)}` }),
    Plot.line(visiblePath, { x: "day", y: "spot", stroke: "#2196F3", strokeWidth: 2 }),
    Plot.line(visiblePath, { x: "day", y: "futures", stroke: "#ff7f0e", strokeWidth: 2 }),
    Plot.areaY(visiblePath, { x: "day", y1: "spot", y2: "futures", fill: "#ff7f0e", fillOpacity: 0.1 }),
    hedgeLocked && lockedF !== null ? Plot.ruleY([lockedF], { stroke: "#ff7f0e", strokeDasharray: "6,4", strokeOpacity: 0.9, title: `Locked futures price F_${hedgeDay} = ${formatCurrency(lockedF)}` }) : null,
    Plot.ruleX([selectedSnapshot.day], { stroke: "#555", strokeDasharray: "3,3", strokeOpacity: 0.6 }),
    Plot.dot([selectedSnapshot], { x: "day", y: "spot", stroke: "white", fill: "#2196F3", r: 4 }),
    Plot.dot([selectedSnapshot], { x: "day", y: "futures", stroke: "white", fill: "#ff7f0e", r: 4 })
  ].filter(Boolean)
})

basisLegend = html`<div class="plot-legend">
  <span><span class="swatch" style="background: #2196F3;"></span>Spot price</span>
  <span><span class="swatch" style="background: #ff7f0e;"></span>Futures price</span>
</div>`

html`${basisLegend}`

basisPanel = {
  const data = [
    {
      Metric: "Day",
      Value: selectedSnapshot.day
    },
    {
      Metric: "Hedge Position",
      Value: hedgeSide
    },
    {
      Metric: "Spot price",
      Value: formatCurrency(selectedSnapshot.spot)
    },
    {
      Metric: "Futures price",
      Value: formatCurrency(selectedSnapshot.futures)
    },
    {
      Metric: hedgeLocked ? `Locked futures price F_${hedgeDay}` : "Locked futures price",
      Value: hedgeLocked && lockedF !== null ? formatCurrency(lockedF) : "No hedge active"
    },
    {
      Metric: "Basis",
      Value: `${formatSigned(selectedSnapshot.basis)} (${basisMood(selectedSnapshot.basis)})`
    },
    hedgeActiveOnDay && lockedF !== null
      ? {
          Metric: hedgeSide === "Short" ? "Effective Sale Price" : "Effective Purchase Price",
          Value: `${formatCurrency(effectivePrice)} = ${formatCurrency(lockedF)} + ${formatSigned(selectedSnapshot.basis)}`
        }
      : {
          Metric: "Effective Price",
          Value: hedgeLocked
            ? `Hedge starts on day ${hedgeDay}; move the slider to day ${hedgeDay} or later`
            : "Lock a hedge to compute"
        },
    {
      Metric: `Basis at expiration (day ${finalSnapshot.day})`,
      Value: `${formatSigned(finalSnapshot.basis)} (${basisMood(finalSnapshot.basis)})`
    }
  ];
  return htl.html`<table class="table" style="width: 100%;"><tbody>${data.map(row => htl.html`<tr><td style="width: 45%; font-weight: 500;">${row.Metric}</td><td>${row.Value}</td></tr>`)}</tbody></table>`;
}

Note

A Note on Terminology

In this simulation’s summary table, for simplicity, we label a positive basis as “strengthening” and a negative basis as “weakening.” In practice, strengthening or weakening refers to the change in the basis over time. A basis strengthens if it becomes more positive or less negative.

md`The outcome of the hedge depends on your position. A **strengthening basis** (more positive) helps a **short hedger** by increasing their effective selling price, but hurts a **long hedger** by increasing their effective purchase cost. Conversely, a **weakening basis** (more negative) hurts a short hedger but helps a long hedger.

Because the simulated futures contract is written on the same asset as the spot exposure, the basis converges to zero at expiration: a hedge held all the way to the delivery date locks in the futures price exactly. Basis risk arises when the hedge is closed out before that date, or when the futures contract is written on a different asset.`

Reference

This page accompanies Chapter 3 of Hull (2022).

References

Hull, John. 2022. Options, Futures, and Other Derivatives. 11th ed. Pearson.