Cost of carry

The cost of carry links the spot price of an asset to the forward price investors require to postpone ownership. Financing costs push the forward price up, while any income the asset generates pulls it down. Storage costs are cash outlays that must also be compensated for in the forward price. Thinking about all three at once can be tricky, so it helps to build the forward curve component by component.

From spot to forward

For an asset with continuous carry costs and benefits, the no-arbitrage forward price at time 0 for maturity $T$ is

\[ F_0(T) = S_0 \times e^{(c)T} = S_0 \times e^{(r + u - q - y)T}, \]

where the net cost of carry is $c = r + u - q - y$. The components are:
* $r$: the financing rate (opportunity cost of capital).
* $u$: non-recoverable storage costs.
* $q$: the dividend yield that accrues to spot holders.
* $y$: the convenience yield, a non-monetary benefit from holding the physical asset (e.g., avoiding shortages).

Financing ($r$) and storage ($u$) are costs to an investor holding the asset, so they increase the forward price. Dividends ($q$) and convenience yield ($y$) are benefits of holding the asset, so they decrease the forward price.

Interactive cost of carry lab

Use the lab below to layer in financing, dividends, storage, and convenience yield. Start with the spot price, then click the buttons to reveal each component. As you adjust sliders, the bar chart shows how each element contributes to the net cost of carry, the formula updates in real time, and the forward curve pivots to reflect the combined effect. A simulated spot price path is also shown for context.

Tip

How to experiment

The initial spot price $S_0$ is fixed at $100.
Click Resimulate spot path to generate a new random price trajectory.
Click a button (e.g., “Add Financing Cost”) to reveal a component slider and see how it affects the futures price.
Watch the contributions accumulate in the bar chart.
Observe how the gap (the basis) between the spot and futures price changes.

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

formatPercent = value => `${(value * 100).toFixed(1)}%`
formatSignedPercent = value => `${value >= 0 ? "+" : "-"}${(Math.abs(value) * 100).toFixed(1)}%`

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 distribution 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)
}

makeToggleSlider = ({
  addLabel,
  removeLabel,
  sliderLabel,
  min,
  max,
  step,
  initial,
  format = formatPercent
}) => {
  let active = false
  let current = initial

  const container = html`<div style="display: flex; flex-direction: column; gap: 0.5rem;"></div>`
  const button = html`<button style="background: white; color: #2f71d5; border: 1px solid #2f71d5; border-radius: 6px; padding: 0.35rem 0.9rem; font-weight: 500; font-size: 0.9rem; cursor: pointer; align-self: flex-start;">${addLabel}</button>`
  const sliderWrap = html`<div style="display: none; align-items: center; gap: 0.75rem; flex-wrap: wrap; background: #f8f9fa; border: 1px solid #dee2e6; border-radius: 8px; padding: 0.6rem 0.8rem;"></div>`
  const label = html`<span style="min-width: 9rem; font-weight: 500;">${sliderLabel}</span>`
  const slider = html`<input type="range" min="${min}" max="${max}" step="${step}" value="${initial}" style="flex: 1;" aria-label="${sliderLabel}">`
  const valueBadge = html`<span style="font-variant-numeric: tabular-nums; font-weight: 600; color: #343a40;">${format(initial)}</span>`

  const syncUI = () => {
    button.textContent = active ? removeLabel : addLabel
    button.style.background = active ? "#2f71d5" : "white"
    button.style.color = active ? "white" : "#2f71d5"
    sliderWrap.style.display = active ? "flex" : "none"
  }

  const emit = () => {
    container.value = { active, rate: current }
    container.dispatchEvent(new CustomEvent("input", { bubbles: true }))
  }

  slider.addEventListener("input", event => {
    current = Number(event.target.value)
    valueBadge.textContent = format(current)
    emit()
  })

  button.addEventListener("click", () => {
    active = !active
    syncUI()
    emit()
  })

  syncUI()
  sliderWrap.append(label, slider, valueBadge)
  container.append(button, sliderWrap)

  emit()
  return container
}

mutable resimulateClicks = 0

viewof resimulateButton = {
  const button = htl.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>`;
  button.onclick = () => {
    mutable resimulateClicks += 1;
  };
  // We need to yield the mutable value to ensure cells that depend on it rerun.
  mutable resimulateClicks;
  return button;
}

// Initial spot price is now fixed
baseSpot = 100

viewof financingControl = makeToggleSlider({
  addLabel: "Add Financing Cost (r)",
  removeLabel: "Remove Financing Cost (r)",
  sliderLabel: "Financing rate r",
  min: 0,
  max: 0.12,
  step: 0.001,
  initial: 0.03
})

viewof dividendControl = makeToggleSlider({
  addLabel: "Add Dividend Yield (q)",
  removeLabel: "Remove Dividend Yield (q)",
  sliderLabel: "Dividend yield q",
  min: 0,
  max: 0.08,
  step: 0.001,
  initial: 0.02
})

viewof storageControl = makeToggleSlider({
  addLabel: "Add Storage Costs (u)",
  removeLabel: "Remove Storage Costs (u)",
  sliderLabel: "Storage cost u",
  min: 0,
  max: 0.06,
  step: 0.001,
  initial: 0.01
})

viewof convenienceYieldControl = makeToggleSlider({
  addLabel: "Add Convenience Yield (y)",
  removeLabel: "Remove Convenience Yield (y)",
  sliderLabel: "Convenience yield y",
  min: 0,
  max: 0.1,
  step: 0.001,
  initial: 0.0
})

carryState = {
  const financing = financingControl.active ? financingControl.rate : 0;
  const dividend = dividendControl.active ? dividendControl.rate : 0;
  const storage = storageControl.active ? storageControl.rate : 0;
  const convenience = convenienceYieldControl.active ? convenienceYieldControl.rate : 0;
  const net = financing + storage - dividend - convenience;
  return {
    spot: baseSpot,
    financing,
    dividend,
    storage,
    convenience,
    net
  };
}

carryBarData = [
  { component: "Financing cost (r)", value: carryState.financing },
  { component: "Storage cost (u)", value: carryState.storage },
  { component: "Dividend yield (q)", value: -carryState.dividend },
  { component: "Convenience yield (y)", value: -carryState.convenience }
]

carryChart = Plot.plot({
  height: 260,
  marginLeft: 60,
  marginBottom: 60,
  x: {
    label: null,
    tickRotate: -20
  },
  y: {
    label: "Contribution to net carry",
    grid: true,
    tickFormat: d => `${(d * 100).toFixed(0)}%`
  },
  color: {
    legend: false
  },
  marks: [
    Plot.barY(carryBarData, {
      x: "component",
      y: "value",
      fill: d => d.value >= 0 ? "#2f71d5" : "#0ca678",
      title: d => `${d.component}: ${formatSignedPercent(d.value)}`
    }),
    Plot.ruleY([carryState.net], {
      stroke: "#ff7f0e",
      strokeDash: [6, 4],
      strokeWidth: 2,
      title: `Net cost of carry: ${formatSignedPercent(carryState.net)}`
    }),
    Plot.ruleY([0], { stroke: "#868e96", strokeOpacity: 0.6 })
  ]
})

maxYears = 1

priceSimulation = {
  const seed = 12345 + resimulateClicks;
  const rng = mulberry32(seed);
  const dt = 1 / 252;
  const sigma = 0.20;
  const mu = 0.05;
  const path = [];
  let spot = baseSpot;
  const contractMaturity = maxYears;

  for (let t = 0; t <= contractMaturity + 1e-8; t += dt) {
    const remainingMaturity = Math.max(0, contractMaturity - t);
    const futures = spot * Math.exp(carryState.net * remainingMaturity);
    path.push({ t, spot, futures });

    const drift = (mu - 0.5 * sigma ** 2) * dt;
    const diffusion = sigma * Math.sqrt(dt) * randomNormal(rng);
    spot = spot * Math.exp(drift + diffusion);
  }
  return path;
}

priceChart = Plot.plot({
  height: 320,
  marginLeft: 64,
  marginBottom: 60,
  x: {
    label: "Time t (years)",
    domain: [0, maxYears]
  },
  y: {
    label: "Price (USD)",
    grid: true,
    tickFormat: d => formatCurrency(d, 0)
  },
  marks: [
    Plot.areaY(priceSimulation, { 
      x: "t", 
      y1: "spot", 
      y2: "futures", 
      fill: "#6c757d", 
      fillOpacity: 0.15, 
      title: d => `Basis at t=${d.t.toFixed(2)}: ${formatCurrency(d.spot - d.futures, 2)}`
    }),
    Plot.line(priceSimulation, {
      x: "t",
      y: "spot",
      stroke: "#495057",
      strokeWidth: 1.5,
      strokeDash: [2, 2]
    }),
    Plot.line(priceSimulation, {
      x: "t",
      y: "futures",
      stroke: "#2f71d5",
      strokeWidth: 3
    }),
    Plot.crosshair(priceSimulation, {x: "t", y: "spot", color: "#495057"}),
    Plot.tip(
      priceSimulation,
      Plot.pointerX({
        x: "t",
        title: d => `t = ${d.t.toFixed(2)}\nSpot: ${formatCurrency(d.spot, 2)}\nFutures: ${formatCurrency(d.futures, 2)}\nBasis: ${formatCurrency(d.spot - d.futures, 2)}`
      })
    )
  ]
})

summaryData = {
  const initial = priceSimulation[0];
  const final = priceSimulation[priceSimulation.length - 1];
  const rows = [
    { label: "Spot price S_0", value: formatCurrency(initial.spot, 2) },
    { label: "Initial futures price F_0", value: formatCurrency(initial.futures, 2) },
    { label: "Initial basis (S_0 - F_0)", value: formatCurrency(initial.spot - initial.futures, 2) },
    { label: "Final price at T=1", value: formatCurrency(final.spot, 2) },
    { label: "Net cost of carry c", value: formatSignedPercent(carryState.net) },
  ];
  return htl.html`<table class="table" style="width: 100%; margin-top: 0.5rem;"><tbody>
    ${rows.map(row => htl.html`<tr><td style="width: 48%; font-weight: 500;">${row.label}</td><td>${row.value}</td></tr>`)}
  </tbody></table>`;
}

formulaDisplay = {
  // Depend on the latest slider state so we recompute the text
  carryState;

  const { net, spot } = carryState;
  const initialFutures = spot * Math.exp(net * maxYears);

  const parts = [];
  if (financingControl.active) parts.push("r");
  if (storageControl.active) parts.push("u");
  if (dividendControl.active) parts.push("-q");
  if (convenienceYieldControl.active) parts.push("-y");

  let exponentString = parts.join(" + ").replace(/ \+ -/g, " - ");
  if (exponentString === "") exponentString = "0";

  const spotValue = spot.toFixed(2);
  const netValue = net.toFixed(4);
  const futuresValue = initialFutures.toFixed(2);
  const spotCurrency = formatCurrency(spot, 2);
  const futuresCurrency = formatCurrency(initialFutures, 2);

  return md`
The futures price ${tex`F_t`} for a contract with maturity ${tex`T`} depends on the spot price ${tex`S_t`} and the remaining time ${tex`(T - t)`}:
${tex.block`F_t(T) = S_t \times e^{c (T - t)}`}
where the net cost of carry is ${tex`c = ${exponentString}`}. At time ${tex`t = 0`}, with ${tex`S_0 = ${spotValue}`}, ${tex`T = 1`}, and ${tex`c = ${netValue}`}, the initial futures price is
${tex.block`F_0(1) = ${spotValue} \times e^{${netValue} \times 1} = ${futuresValue}`}
Numerically this corresponds to a spot of ${spotCurrency} and a futures price of ${futuresCurrency}. As time ${tex`t`} passes, ${tex`S_t`} fluctuates and the remaining time ${tex`(T - t)`} shrinks, causing the futures price to converge toward the spot price.`;
}

priceChartLegend = htl.html`<div style="display: flex; align-items: center; flex-wrap: wrap; gap: 1rem; font-size: 0.9rem; margin-top: 0.5rem; justify-content: center;">
  <span><span style="display: inline-block; width: 20px; height: 4px; background: #2f71d5; vertical-align: middle; margin-right: 5px;"></span>Futures Price (F_t)</span>
  <span><span style="display: inline-block; width: 20px; height: 0px; border-top: 2px dashed #495057; vertical-align: middle; margin-right: 5px;"></span>Spot Price (S_t)</span>
  <span><span style="display: inline-block; width: 20px; height: 12px; background: #6c757d; opacity: 0.25; vertical-align: middle; margin-right: 5px;"></span>Basis</span>
</div>`

html`<div style="margin-top: 1rem;">
  <div>${priceChart}${priceChartLegend}</div>
  <div style="margin-top: 1.5rem;">${carryChart}</div>
</div>`

html`<div style="margin-top: 1rem;">${summaryData}${formulaDisplay}</div>`

Interpreting the Curve

The chart now shows the evolution of the spot price ($S_t$, grey dashed line) and the futures price ($F_t$, blue line) over one year for a contract maturing at $T=1$.

Cost of Carry Impact: The gap between the two lines at the start ($t=0$) is determined by the net cost of carry. A positive net carry ($c > 0$) puts the market in contango, where the futures price is higher than the spot price. A negative net carry ($c < 0$) causes backwardation, where the futures price is lower than the spot price.
Convergence: As time passes, the remaining time to maturity shrinks. This reduces the impact of the cost of carry, forcing the futures price to converge toward the spot price. At maturity ($t=1$), the basis is zero and $F_T = S_T$.
Experiment: Adjust the cost of carry components to see how they change the initial basis. A high convenience yield, for example, is a primary driver of backwardation in commodity markets. Click “Resimulate spot path” to see how the relationship holds for a different random path.