> For the complete documentation index, see [llms.txt](https://gitbook-docs.coinmetrics.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gitbook-docs.coinmetrics.io/market-data/market-data-overview/market-greeks.md).

# Market Greeks

## Overview

Option greeks measure how an option's price responds to changes in the factors that drive it. This dataset delivers the standard greeks (delta, gamma, vega, theta, and rho) for individual option markets, exactly as each exchange reports them. It answers a practical question for anyone holding or pricing options: how sensitive is this contract to moves in the underlying, in implied volatility, in the passage of time, and in interest rates? Traders and risk teams use greeks to size positions and construct hedges that achieve a desired exposure.

## At a Glance

<table data-full-width="true"><thead><tr><th>Data type</th><th>Entities</th><th width="159">Frequency / cadence</th><th>Unit</th><th>Primary endpoint</th><th>Coverage</th></tr></thead><tbody><tr><td>Market greeks</td><td>Markets (options)</td><td>Up to one observation per market per minute (deduplicated); <code>granularity</code> supports raw / 1m / 1h / 1d</td><td>Sensitivity values, as reported by the exchange (per greek)</td><td><code>/timeseries/market-greeks</code></td><td><a href="https://coverage.coinmetrics.io/market-greeks-v2">🔗</a></td></tr></tbody></table>

## Schema

Each row is one option market's greeks at a point in time. Values are returned as JSON strings to preserve precision, and greek fields that an exchange does not report are null.

| Field           | Type               | Description                                                                                                                                                                                       | Notes                                                                                                      |
| --------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `market`        | string             | Unique name of the market. Option market ids follow the convention `exchangeName-optionsSymbol-option`.                                                                                           | Required                                                                                                   |
| `time`          | string (date-time) | The observation time in ISO 8601 date-time format, aligned to the start of the minute (it is `exchange_time` truncated to the minute). Always nanosecond precision.                               | Required. See [Timestamps](#timestamps)                                                                    |
| `delta`         | string (decimal)   | The first derivative of the option's price with respect to the underlying asset's price.                                                                                                          | Optional                                                                                                   |
| `gamma`         | string (decimal)   | The second derivative of the option's price with respect to the underlying asset's price.                                                                                                         | Optional                                                                                                   |
| `vega`          | string (decimal)   | The first derivative of the option's price with respect to the volatility of the underlying asset's price.                                                                                        | Optional                                                                                                   |
| `theta`         | string (decimal)   | The first derivative of the option's price with respect to the passage of time.                                                                                                                   | Optional                                                                                                   |
| `rho`           | string (decimal)   | The first derivative of the option's price with respect to the risk-free interest rate.                                                                                                           | Optional. Reported by only some venues, otherwise null. See [Sourcing](#sourcing-exchange-reported-greeks) |
| `exchange_time` | string (date-time) | The full-precision timestamp of the observation. For venues that provide their own ticker timestamp this is the exchange's time, otherwise it reflects when the value was collected. Can be null. | Optional. See [Timestamps](#timestamps)                                                                    |
| `database_time` | string (date-time) | The time Coin Metrics saved the observation to the database, in ISO 8601 date-time format with nanosecond precision.                                                                              | Required                                                                                                   |

{% hint style="info" %}
**Conventions.** Decimal values are returned as JSON strings to preserve precision. Timestamps are UTC ISO-8601 with nanosecond resolution. `time` is the observation time aligned to the start of the minute (it is `exchange_time` truncated to the minute), `exchange_time` is the full-precision timestamp of the observation, and `database_time` is when Coin Metrics saved it. See [Timestamps](#timestamps) for how the three relate. Greek fields that are not reported are null and are omitted from JSON responses.
{% endhint %}

## Methodology

Market greeks are sourced from exchanges and delivered with minimal processing. The subsections below describe where the values come from, how often they are recorded, what each timestamp means, and how the `granularity` parameter shapes the returned series.

### Sourcing: exchange-reported greeks

Greeks are collected directly from each option exchange's ticker feed and passed through unchanged. Coin Metrics does not recompute greeks with its own pricing model. Each value is stored verbatim as the exchange reports it, as a high-precision decimal, with no scaling or rounding applied. Because the values originate with the exchange, the exact set of greeks provided varies by venue. In particular, `rho` is reported by only some venues and is null elsewhere. The unit conventions behind each greek (for example whether theta is expressed per day and vega per one percentage point of volatility) are also defined by the reporting exchange and can differ across venues.

### Collection cadence and deduplication

Each option market's ticker is collected on an ongoing basis. Coin Metrics deduplicates the collected observations so that at most one record is kept per market per minute: the first observation seen within a given minute is retained and later observations in that same minute are discarded. As a result, the raw series contains at most one row per market per minute, and `time` is aligned to the minute.

### Timestamps

Three timestamps accompany every observation, and they are derived from one another rather than being independent.

`exchange_time` is the full-precision timestamp of the observation. When a venue stamps its ticker with its own time, `exchange_time` carries that exchange time. For venues that do not, it reflects the moment Coin Metrics collected the value. Treat it as the precise time of the observation, but not necessarily as the exchange's own clock for every venue.

`time` is `exchange_time` truncated to the start of its minute (the seconds and sub-seconds are zeroed). Because at most one observation is retained per market per minute (the first one seen in that minute, see [Collection cadence and deduplication](#collection-cadence-and-deduplication)), `time` labels the minute while `exchange_time` shows where within that minute the retained observation actually fell. Use `time` to order and join the series (its values are exactly one minute apart), and `exchange_time` when you need the precise moment.

`database_time` is when Coin Metrics saved the observation. It is always populated and lands shortly after `exchange_time`.

### Granularity and downsampling

By default (`granularity=raw`) the endpoint returns every stored observation, up to one per minute. Setting `granularity` to `1m`, `1h`, or `1d` downsamples the series by returning the first observation in each interval and dropping the rest. Downsampling selects existing rows: it does not modify or re-align the values, so the returned `time` values remain the original observation times.

### Availability and timeliness

Greeks are served without an added delay. An observation becomes queryable as soon as it is collected and stored, subject to the one-per-minute deduplication above. The dataset covers option markets only. Per-market history and the current list of covered markets are shown on the [coverage page](https://coverage.coinmetrics.io/market-greeks-v2).

## Accessing the Data

Greeks are served from the `/timeseries/market-greeks` endpoint, keyed by one or more option `markets`. The examples below request a single Deribit BTC option over a one-day window. The Python API Client is the recommended path.

{% tabs %}
{% tab title="Python Client" %}

```python
import os
from datetime import timedelta
from coinmetrics.api_client import CoinMetricsClient

client = CoinMetricsClient(os.environ["CM_API_KEY"])

df = (
    client.get_market_greeks(
        markets=["deribit-BTC-20JUL26-72000-C-option"],
        start_time="2026-07-16",
        end_time="2026-07-17",
        format="json_stream",
    )
    .parallel(time_increment=timedelta(days=1))
    .to_dataframe()
)
print(df)
```

{% endtab %}

{% tab title="Shell" %}

```shell
curl --compressed "https://api.coinmetrics.io/v4/timeseries/market-greeks?markets=deribit-BTC-20JUL26-72000-C-option&start_time=2026-07-16&end_time=2026-07-17&api_key=$CM_API_KEY"
```

{% endtab %}

{% tab title="Python" %}

```python
import os
import requests

url = "https://api.coinmetrics.io/v4/timeseries/market-greeks"
params = {
    "markets": "deribit-BTC-20JUL26-72000-C-option",
    "start_time": "2026-07-16",
    "end_time": "2026-07-17",
    "api_key": os.environ["CM_API_KEY"],
}
print(requests.get(url, params=params).json())
```

{% endtab %}
{% endtabs %}

To retrieve only the most recent values, replace the time range with `limit_per_market=1`. To downsample a long history, add the `granularity` parameter (see [Granularity and downsampling](#granularity-and-downsampling)).

Full parameter reference: see the API Reference for [`/timeseries/market-greeks`](https://docs.coinmetrics.io/api/v4/#operation/getTimeseriesMarketGreeks).

## Examples

### Example: Deribit BTC option greeks

The rows below are consecutive one-minute observations for the `deribit-BTC-20JUL26-72000-C-option` market. This is a Deribit option, so every greek including `rho` and the exchange-reported `exchange_time` is populated. [Open in browser ↗](https://api.coinmetrics.io/v4/timeseries/market-greeks?markets=deribit-BTC-20JUL26-72000-C-option\&limit_per_market=3\&api_key=YOUR_API_KEY)

```json
{
  "data": [
    {
      "market": "deribit-BTC-20JUL26-72000-C-option",
      "time": "2026-07-16T14:29:00.000000000Z",
      "database_time": "2026-07-16T14:29:02.970981000Z",
      "vega": "1.00642",
      "theta": "-4.64139",
      "rho": "0.03499",
      "delta": "0.00536",
      "gamma": "0.00001",
      "exchange_time": "2026-07-16T14:29:01.202000000Z"
    },
    {
      "market": "deribit-BTC-20JUL26-72000-C-option",
      "time": "2026-07-16T14:30:00.000000000Z",
      "database_time": "2026-07-16T14:30:01.884768000Z",
      "vega": "1.02137",
      "theta": "-4.76075",
      "rho": "0.03557",
      "delta": "0.00545",
      "gamma": "0.00001",
      "exchange_time": "2026-07-16T14:30:00.636000000Z"
    },
    {
      "market": "deribit-BTC-20JUL26-72000-C-option",
      "time": "2026-07-16T14:31:00.000000000Z",
      "database_time": "2026-07-16T14:31:03.022917000Z",
      "vega": "0.98698",
      "theta": "-4.57026",
      "rho": "0.03423",
      "delta": "0.00525",
      "gamma": "0.00001",
      "exchange_time": "2026-07-16T14:31:02.516000000Z"
    }
  ]
}
```

## Coverage

Coverage lists every option market with greeks, along with each market's available time range.

{% embed url="<https://coverage.coinmetrics.io/market-greeks-v2>" %}

## Limitations

A few properties of this dataset are worth keeping in mind.

* **Option markets only.** Greeks are available for option markets. A request for a spot or futures market returns an error, and non-option markets selected by a pattern are omitted from the response.
* **Exchange-dependent completeness.** Because greeks are passed through from each exchange, the set of populated greeks varies by venue. `rho` is reported by only some venues and is null otherwise. Null greek fields are omitted from JSON responses.
* **Exchange-defined conventions.** Greek values and their unit conventions are those of the reporting exchange. Coin Metrics does not normalize them to a common convention, so values are best compared within a venue.
* **Minute-level resolution.** At most one observation is stored per market per minute, so the dataset does not capture sub-minute changes in greeks.

## FAQ

### Does Coin Metrics calculate the greeks?

No. Greeks are collected as reported by each option exchange and passed through unchanged. Coin Metrics does not recompute them with its own model.

### Why are some greeks, like rho, missing?

Exchanges report different subsets of greeks. `rho` in particular is provided by only some venues. When a value is not reported, the field is null and is omitted from JSON responses.

### Can I get greeks for futures or spot markets?

No. The dataset covers option markets only. Requesting a non-option market returns an error.

### How often do greeks update?

Observations are collected continuously and deduplicated to at most one per market per minute. Use the `granularity` parameter (`raw`, `1m`, `1h`, `1d`) to downsample a long history to a coarser cadence.

### What is the difference between `time` and `exchange_time`?

`time` is `exchange_time` truncated to the start of the minute, and it is the field to sort or join on (its values are exactly one minute apart). `exchange_time` is the full-precision timestamp of the retained observation, so it falls somewhere within the minute labeled by `time`. For venues that provide their own ticker timestamp, `exchange_time` is the exchange's clock. For others, it reflects the collection time.

## Related

* [Market Contract Prices](/market-data/market-data-overview/market-contract-prices.md): mark, index, and estimated settlement prices for the same option and futures markets.
* [Market Implied Volatility](/market-data/market-data-overview/volatility/market-implied-volatility.md): exchange-reported implied volatility for option markets.
* [Market Open Interest](/market-data/market-data-overview/market-open-interest.md): open contracts outstanding for derivatives markets.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://gitbook-docs.coinmetrics.io/market-data/market-data-overview/market-greeks.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.