Understanding Greeks

The Diffusal API returns option Greeks with every ticker and position response. This guide explains what each Greek measures and how to use them.

What Are Greeks?

Greeks are risk measures that describe how an option's price changes in response to various factors. They're essential for:

Risk management: Understanding your portfolio's exposure
Hedging: Calculating hedge ratios
Trading decisions: Evaluating option sensitivity

Delta ( $\delta$ )

What it measures: How much the option price changes when the underlying price moves by $1.

Interpretation

Delta Value	Meaning
0.50	Option gains $0.50 when underlying rises$ 1
-0.30	Option loses $0.30 when underlying rises$ 1
1.00	Deep in-the-money call, moves 1:1 with underlying
0.00	Deep out-of-the-money, minimal price sensitivity

Sign Conventions

Position	Delta Sign
Long call	Positive (+)
Short call	Negative (-)
Long put	Negative (-)
Short put	Positive (+)

API Example

const ticker = await fetch(`${API_URL}/markets/ticker/${symbol}`).then((r) =>
  r.json()
);

const delta = Number(ticker.delta) / 1e18; // Convert from WAD

console.log(`Delta: ${delta.toFixed(4)}`);
// Delta: 0.5500 means the option moves $0.55 per $1 move in the underlying

Use Case: Delta Hedging

To delta-hedge a position, calculate the hedge ratio:

// If you're long 10 calls with delta 0.55
const contracts = 10;
const delta = 0.55;
const hedgeAmount = contracts * delta; // 5.5

// Short 5.5 units of underlying to be delta-neutral

Gamma ( $\gamma$ )

What it measures: How much delta changes when the underlying price moves by $1. It's the "delta of delta."

Interpretation

Gamma Value	Meaning
High (> 0.05)	Delta changes rapidly; option is near ATM or expiry
Low (< 0.01)	Delta is stable; option is deep ITM/OTM

Key Properties

Always positive for long options (calls and puts)
Highest for at-the-money options near expiry
Gamma risk increases as expiration approaches

API Example

const gamma = Number(ticker.gamma) / 1e18;

console.log(`Gamma: ${gamma.toFixed(6)}`);
// Gamma: 0.001200 means delta changes by 0.0012 per $1 move

Use Case: Gamma Exposure

// Calculate how your delta changes if BTC moves $1000
const gamma = 0.0012;
const priceMove = 1000;
const deltaChange = gamma * priceMove; // 1.2

// If delta was 0.55, after a $1000 move it becomes 0.55 + 1.2 = 1.75
// (capped at 1.0 in practice)

Vega ( $\nu$ )

What it measures: How much the option price changes when implied volatility changes by 1 percentage point.

Interpretation

Vega Value	Meaning
50	Option gains $50 if IV rises from 80% to 81%
10	Option gains $10 per 1% IV increase

Key Properties

Always positive for long options
Highest for at-the-money options
Increases with longer time to expiry

API Example

const vega = Number(ticker.vega) / 1e18;
const iv = Number(ticker.iv) / 1e18;

console.log(`Vega: ${vega.toFixed(2)}`);
console.log(`Current IV: ${(iv * 100).toFixed(1)}%`);
// Vega: 50.00
// Current IV: 80.0%

Use Case: Volatility Trading

// If you expect IV to rise from 80% to 85%
const vega = 50;
const ivChange = 5; // percentage points
const expectedProfit = vega * ivChange; // $250 per contract

console.log(`Expected profit from IV increase: $${expectedProfit}`);

Theta ( $\theta$ )

What it measures: How much the option price decays per day due to time passing (time decay).

Interpretation

Theta Value	Meaning
-5	Option loses $5 per day from time decay
-0.5	Option loses $0.50 per day

Key Properties

Negative for long options (you pay time decay)
Positive for short options (you collect time decay)
Accelerates as expiration approaches ("theta burn")
Highest for ATM options near expiry

API Example

const theta = Number(ticker.theta) / 1e18;

console.log(`Theta: ${theta.toFixed(4)}`);
// Theta: -0.0100 means the option loses $0.01 per day

Use Case: Time Decay Analysis

// Calculate weekly time decay
const dailyTheta = -10; // $10 per day
const daysToExpiry = 7;
const weeklyDecay = dailyTheta * 7; // -$70

// For a short option position, this is income
const shortPositionIncome = -weeklyDecay; // +$70

Rho ( $\rho$ )

What it measures: How much the option price changes when interest rates change by 1 percentage point.

Interpretation

Rho Value	Meaning
5	Option gains $5 if rates rise from 5% to 6%
-3	Option loses $3 if rates rise 1%

Key Properties

Calls have positive rho (benefit from higher rates)
Puts have negative rho (hurt by higher rates)
Less significant in crypto (typically < 1% of option value)
More important for longer-dated options

API Example

const rho = Number(ticker.rho) / 1e18;

console.log(`Rho: ${rho.toFixed(4)}`);
// Rho: 0.0050 means the option gains $0.005 per 1% rate increase

Position Greeks

When you have a position, the API returns position Greeks which are scaled by your position size:

const positionsRes = await fetch(`${API_URL}/account/portfolios/0/positions`, {
  credentials: "include",
});
const { positions } = await positionsRes.json();

for (const pos of positions) {
  const balance = Number(pos.optionBalance) / 1e18;
  const delta = Number(pos.delta) / 1e18;
  const gamma = Number(pos.gamma) / 1e18;
  const vega = Number(pos.vega) / 1e18;
  const theta = Number(pos.theta) / 1e18;

  console.log(`${pos.symbol}:`);
  console.log(`  Balance: ${balance.toFixed(4)} contracts`);
  console.log(`  Position Delta: ${delta.toFixed(4)}`);
  console.log(`  Position Gamma: ${gamma.toFixed(6)}`);
  console.log(`  Position Vega: ${vega.toFixed(2)}`);
  console.log(`  Position Theta: ${theta.toFixed(4)}`);
}

Aggregating Portfolio Greeks

Sum position Greeks to get portfolio-level exposure:

let portfolioDelta = 0;
let portfolioGamma = 0;
let portfolioVega = 0;
let portfolioTheta = 0;

for (const pos of positions) {
  portfolioDelta += Number(pos.delta) / 1e18;
  portfolioGamma += Number(pos.gamma) / 1e18;
  portfolioVega += Number(pos.vega) / 1e18;
  portfolioTheta += Number(pos.theta) / 1e18;
}

console.log("Portfolio Greeks:");
console.log(`  Total Delta: ${portfolioDelta.toFixed(4)}`);
console.log(`  Total Gamma: ${portfolioGamma.toFixed(6)}`);
console.log(`  Total Vega: ${portfolioVega.toFixed(2)}`);
console.log(`  Total Theta: ${portfolioTheta.toFixed(4)}`);

Greeks Quick Reference

Greek	Measures	Long Option Sign	Short Option Sign
Delta	Price sensitivity to underlying	Call: +, Put: -	Call: -, Put: +
Gamma	Delta sensitivity to underlying	Always +	Always -
Vega	Price sensitivity to volatility	Always +	Always -
Theta	Time decay per day	Always -	Always +
Rho	Price sensitivity to rates	Call: +, Put: -	Call: -, Put: +

WAD Format Conversion

All Greeks from the API are in WAD format (18 decimals). Convert to human-readable:

function fromWad(wadString: string): number {
  return Number(wadString) / 1e18;
}

// Usage
const delta = fromWad(ticker.delta); // 0.55
const gamma = fromWad(ticker.gamma); // 0.0012
const vega = fromWad(ticker.vega); // 50.0
const theta = fromWad(ticker.theta); // -0.01
const rho = fromWad(ticker.rho); // 0.005
const iv = fromWad(ticker.iv); // 0.80 (80%)

Black-Scholes - Pricing model that derives these Greeks
API Reference - Ticker endpoint details
Reference - Data type specifications
Quick Start - Getting started guide

Understanding Greeks

On this page