# Greeks

`GET` `https://api.unusualwhales.com/api/socket/greeks`

**NOTE:**
This is the documentation for websocket channels `greeks` and `greeks:<TICKER>`.
Websocket access for personal use is only available through the [Advanced plan](https://unusualwhales.com/pricing?product=api).

You can find fully-functional examples that stream data from many channels here:

- Python: [https://github.com/unusual-whales/api-examples/tree/main/examples/ws-multi-channel-multi-output](https://github.com/unusual-whales/api-examples/tree/main/examples/ws-multi-channel-multi-output)
- Javascript: [https://github.com/unusual-whales/api-examples/tree/main/examples/ws-multi-channel-multi-output-nodejs](https://github.com/unusual-whales/api-examples/tree/main/examples/ws-multi-channel-multi-output-nodejs)



Connect to the websocket URI:

`wss://api.unusualwhales.com/socket?token=<YOUR_API_TOKEN>`

then `join` the channel you wish to stream: `greeks` for every underlying at once,
or `greeks:SPY` for a single one.

Both channels stream the live counterpart of [/api/stock/{ticker}/greeks](https://api.unusualwhales.com/docs#/operations/PublicApi.TickerController.greeks),
with a different shape: the REST endpoint returns one row per strike for a single
expiry with `call_*`/`put_*` field pairs, while these channels stream **one message
per contract**, across all expiries, with a single set of greek fields plus
`option_type`. A message is emitted every time a contract's greeks are recalculated
and its theoretical price moved - for a busy underlying that is many messages per
second across the whole chain.

Weekly/PM index series are folded into their canonical root on both channels:
`greeks:SPX` includes SPXW contracts (likewise VIXW under VIX, NDXP under NDX, RUTW
under RUT). The `ticker` field carries the canonical root; use `option_symbol` to
tell the series apart.

Payload format:

Format for `greeks:<TICKER>`:

```
[
  "greeks:SPY",
  {
    "option_symbol": "SPY261218C00480000",
    "ticker": "SPY",
    "expiry": "2026-12-18",
    "strike": "480",
    "option_type": "call",
    "timestamp": 1726670396000,
    "volatility": 0.2543,
    "delta": 0.5231,
    "gamma": 0.0125,
    "theta": -0.0821,
    "vega": 1.2143,
    "rho": 0.4312,
    "theo": 38.5217,
    "vanna": 0.1123,
    "vomma": 2.3121,
    "veta": -1.0212,
    "speed": -0.0031,
    "zomma": 0.0523,
    "color": -0.0012,
    "ultima": 3.1214,
    "charm": -0.0214
  }
]
```

The global `greeks` channel streams the same per-contract object for every
underlying, tagged `greeks` (the `ticker` field distinguishes them):

```
[
  "greeks",
  {
    "option_symbol": "AAPL261218C00250000",
    "ticker": "AAPL",
    "expiry": "2026-12-18",
    "strike": "250",
    "option_type": "call",
    "timestamp": 1726670396000,
    "volatility": 0.3121,
    "delta": 0.4812,
    "gamma": 0.0214,
    "theta": -0.0712,
    "vega": 0.8123,
    "rho": 0.2145,
    "theo": 14.2317,
    "vanna": 0.0912,
    "vomma": 1.7213,
    "veta": -0.8121,
    "speed": -0.0021,
    "zomma": 0.0312,
    "color": -0.0009,
    "ultima": 2.1123,
    "charm": -0.0118
  }
]
```

**The global `greeks` channel is a firehose.** Every contract of every optionable
underlying is repriced continuously, so this channel is in the same volume class as
`option_trades` and `gex_strike_expiry` - tens of thousands of messages per second
at peak. Prefer `greeks:<TICKER>` unless you genuinely need the whole chain, and if
you do subscribe globally, read the socket on a dedicated task and buffer/flush
rather than processing inline: a client that cannot keep up will have frames
dropped.

Note that unlike the `gex` and `periscope` channels, the greek values on these
channels are JSON **numbers**, not decimal strings: they are floating point
quantities as computed, so you may see full double precision (e.g.
`0.30000000000000004`). Round on your side to whatever precision you display.

Fields:

| Field | Type | Description |
|---|---|---|
| `option_symbol` | string | OSI option symbol; the contract's primary identifier. Keeps the raw series root (e.g. `SPXW...` under `SPX`). |
| `ticker` | string | Canonical underlying root. On `greeks:<TICKER>` it matches the channel key; on the global `greeks` channel it identifies the underlying. |
| `expiry` | date string `YYYY-MM-DD` | Contract expiration. |
| `strike` | decimal string | Strike price. |
| `option_type` | string | `call` or `put`. |
| `timestamp` | int (ms) | Calculation time, unix epoch milliseconds. |
| `volatility` | number | Implied volatility. |
| `delta`, `gamma`, `theta`, `vega`, `rho` | number | First-order greeks. |
| `theo` | number | Theoretical price of the contract. |
| `vanna`, `vomma`, `veta`, `speed`, `zomma`, `color`, `ultima`, `charm` | number | Second-order greeks. |


## Authentication

```
Authorization: Bearer YOUR_API_KEY
```



## Example

### curl

```bash
curl -X GET "https://api.unusualwhales.com/api/socket/greeks" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"
```

### Python

```python
import http.client

conn = http.client.HTTPSConnection("api.unusualwhales.com")
headers = {"Authorization": "Bearer YOUR_API_KEY", "Accept": "application/json"}
conn.request("GET", "/api/socket/greeks", headers=headers)
response = conn.getresponse()
print(response.read().decode("utf-8"))
```

## Response Example

```json
{
  "data": []
}
```