API Reference

Greeks Analytics API

Greeks provides derived options analytics — not raw market data. Every endpoint computes actionable signals in real-time: Greeks, GEX, unusual flow, max pain, and full market overviews.

ℹ

Base URL
https://greeks.pro
All responses are JSON with Content-Type: application/json.

What you can build

Real-time options flow scanners and unusual activity alerts
Gamma exposure dashboards for market makers and traders
Max pain calculators for expiration week strategies
Full-stack options analytics platforms with live WebSocket feeds
Algorithmic signals from IV surface and term structure data

Common Parameters

All analytics endpoints share these query parameters:

Parameter	Type	Required	Description
symbol string	string	Required	Any US stock or ETF ticker symbol (e.g. `AAPL`, `SPY`, `TSLA`). Case-insensitive.
expiration int64 \| "all"	string	Optional	Unix timestamp for a specific expiration date, or `"all"` to include every available expiration. Omit for nearest expiry only.

Security

Authentication

All API requests require a valid API key. Keys follow the format grk_<48 hex characters> and are scoped to your user account and plan tier.

⚠

Never expose your API key in client-side code or public repositories. Keys can be rotated at any time from your Settings page.

Methods

You can authenticate using any of three methods. HTTP header methods are preferred.

Header (preferred)

X-API-Key: grk_abc123…

Bearer Token

Authorization: Bearer grk_abc123…

Query Parameter (WebSocket only)

?key=grk_abc123…

Required for WebSocket connections where headers cannot be set.

            
            
            
          
# Using X-API-Key header (recommended)
curl https://greeks.pro/api/analytics/maxpain \
  -H "X-API-Key: grk_your_key_here" \
  -G -d "symbol=AAPL"
const res = await fetch('https://greeks.pro/api/analytics/maxpain?symbol=AAPL', {
  headers: {
    'X-API-Key': 'grk_your_key_here'
  }
});
const data = await res.json();
console.log(data);
import requests

res = requests.get(
    'https://greeks.pro/api/analytics/maxpain',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'AAPL'}
)
data = res.json()

Quotas

Rate Limits & Quotas

Rate limits are enforced per user account using a sliding 60-second window. Daily quotas reset at midnight UTC.

Response Headers

Every response includes rate limit metadata in the headers:

Header	Description
X-RateLimit-Limit	Maximum requests allowed per 60-second window
X-RateLimit-Remaining	Requests remaining in current window
X-Daily-Limit	Maximum requests allowed per day
X-Daily-Remaining	Requests remaining today
Retry-After	Seconds to wait before retrying (only on 429 responses)

Plan Limits

Plan	Requests / min	Requests / day
Free	10	600
Trader	60	5,000
Pro	300	50,000
Institutional	1,000	Unlimited

ℹ

When rate limited (429), wait the number of seconds in Retry-After before retrying. Exponential backoff is recommended for server-side integrations.

REST API

Endpoints

All endpoints are read-only GET requests that return derived analytics computed from live options chain data.

GET /api/analytics/maxpain Free+

Returns the max pain strike for each expiration — the price at which options sellers collectively pay out the least. Useful for identifying magnetic price levels heading into expiration week.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol (e.g. `AAPL`)
expiration	int64 \| "all"	Optional	Unix timestamp or `"all"` for all expirations

                
                
                
              
curl "https://greeks.pro/api/analytics/maxpain?symbol=NDAQ&expiration=all" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/maxpain?symbol=NDAQ&expiration=all',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const { symbol, spotPrice, results } = await res.json();
import requests

data = requests.get(
    'https://greeks.pro/api/analytics/maxpain',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'NDAQ', 'expiration': 'all'}
).json()

Response Schema

{
  "symbol":     "NDAQ",
  "spotPrice":  81.40,
  "timestamp":  1748390400,
  "results": [
    {
      "expiration":       1748390400,  // unix timestamp
      "dte":              7,            // days to expiration
      "maxPainStrike":    80,           // strike in dollars
      "totalPainAtMax":   1284000,      // aggregate pain at max pain strike
      "spotDistance":     1.40,         // spot - maxPainStrike
      "spotDistancePct":  1.72          // percent distance from spot
    }
  ]
}

GET /api/analytics/greeks Trader+

Returns full Black-Scholes Greeks for every options contract on the chain: delta, gamma, theta, vega, rho, implied volatility, theoretical price and mispricing. Ideal for building scanner tools or risk dashboards.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol
expiration	int64 \| "all"	Optional	Filter to a specific expiration date

                
                
                
              
curl "https://greeks.pro/api/analytics/greeks?symbol=NDAQ&expiration=1773964800" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/greeks?symbol=NDAQ&expiration=1773964800',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const { contracts } = await res.json();
// Filter ITM calls with delta > 0.5
const hotCalls = contracts.filter(c => c.type === 'call' && c.delta > 0.5);
import requests

data = requests.get(
    'https://greeks.pro/api/analytics/greeks',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'NDAQ', 'expiration': 1773964800}
).json()

Response Schema

{
  "symbol":    "NDAQ",
  "spotPrice": 81.40,
  "timestamp": 1748390400,
  "contracts": [
    {
      "contractSymbol":  "NDAQ250516C00080000",
      "type":            "call",
      "strike":          80,
      "expiration":      1747353600,
      "dte":             7,
      "iv":              0.2341,       // implied volatility (decimal)
      "delta":           0.6821,
      "gamma":           0.0821,
      "theta":          -0.0412,       // daily theta decay
      "vega":            0.0523,
      "rho":             0.0128,
      "theoreticalPrice": 1.92,
      "mispricing":      0.08,          // market - theoretical
      "inTheMoney":     true
    }
  ]
}

GET /api/analytics/gex Trader+

Returns Gamma Exposure (GEX) and Delta Exposure (DEX) by strike. GEX quantifies the hedging pressure market makers must apply — positive GEX stabilizes price, negative GEX amplifies moves. The gamma flip level is the strike where net GEX crosses zero.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol
expiration	int64 \| "all"	Optional	Recommended: use `"all"` for accurate aggregate GEX
symbols	string	Optional	Comma-separated list of tickers for a bulk request (max 20). When present, `symbol` is ignored. Returns a map of `symbol → GEXResponse`. Counted against per-symbol quota for each ticker.

                
                
                
              
curl "https://greeks.pro/api/analytics/gex?symbol=NDAQ&expiration=all" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/gex?symbol=NDAQ&expiration=all',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const { totalNetGEX, gammaFlip, strikes } = await res.json();
const regime = totalNetGEX > 0 ? 'Stable' : 'Volatile';
import requests

data = requests.get(
    'https://greeks.pro/api/analytics/gex',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'NDAQ', 'expiration': 'all'}
).json()

regime = 'Stable' if data['totalNetGEX'] > 0 else 'Volatile'

Response Schema

{
  "symbol":      "NDAQ",
  "spotPrice":   81.40,
  "timestamp":   1748390400,
  "totalNetGEX": 4821000,   // positive = dealers long gamma (market stabilizing)
  "gammaFlip":   78.50,      // strike where net GEX = 0
  "strikes": [
    {
      "strike":  80,
      "callGEX": 2100000,   // call gamma exposure (positive)
      "putGEX":  -840000,   // put gamma exposure (negative)
      "netGEX":  1260000,
      "callDEX": 980000,
      "putDEX":  -610000,
      "netDEX":  370000
    }
  ]
}

GET /api/analytics/flow Trader+

Detects unusual options activity by scanning for contracts where volume significantly exceeds open interest — a signal that new positions are being opened. Returns ranked signals with severity classification.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol
expiration	int64 \| "all"	Optional	Use `"all"` to scan all expirations for maximum coverage

                
                
                
              
curl "https://greeks.pro/api/analytics/flow?symbol=NDAQ&expiration=all" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/flow?symbol=NDAQ&expiration=all',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const { signals } = await res.json();
// Get high-severity signals only
const highAlert = signals.filter(s => s.severity === 'high');
import requests

data = requests.get(
    'https://greeks.pro/api/analytics/flow',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'NDAQ', 'expiration': 'all'}
).json()

high_signals = [s for s in data['signals'] if s['severity'] == 'high']

Response Schema

{
  "symbol":    "NDAQ",
  "spotPrice": 81.40,
  "timestamp": 1748390400,
  "signals": [
    {
      "contractSymbol": "NDAQ250516C00085000",
      "type":           "call",          // "call" | "put"
      "strike":         85,
      "expiration":     1747353600,
      "dte":            7,
      "volumeOIRatio":  8.42,           // volume / open interest
      "iv":             0.3812,
      "signal":         "unusual_volume", // "unusual_volume" | "opening_position"
      "severity":       "high"           // "high" | "medium"
    }
  ]
}

GET /api/analytics/overview Pro+

Returns the full market overview in a single call — sentiment analysis, GEX summary, max pain, expected moves, IV term structure, IV surface, and top unusual flow. This is the most comprehensive endpoint and powers the full dashboard.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol
expiration	int64 \| "all"	Optional	Recommended: `"all"` for full accuracy across all metrics

                
                
                
              
curl "https://greeks.pro/api/analytics/overview?symbol=NDAQ&expiration=all" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/overview?symbol=NDAQ&expiration=all',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const overview = await res.json();
console.log(overview.sentiment.sentiment); // "bullish" | "bearish" | "neutral"
import requests

overview = requests.get(
    'https://greeks.pro/api/analytics/overview',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'NDAQ', 'expiration': 'all'}
).json()

Response Schema

{
  "symbol":      "NDAQ",
  "spotPrice":   81.40,
  "timestamp":   1748390400,
  "riskFreeRate": 0.0525,

  "sentiment": {
    "sentiment":          "bullish",  // "bullish" | "bearish" | "neutral"
    "putCallVolumeRatio":  0.612,
    "putCallOIRatio":      0.784
  },

  "gexSummary": {
    "totalNetGEX": 4821000,
    "gammaFlip":   78.50
  },

  "maxPain": [
    { "expiration": 1747353600, "dte": 7, "maxPainStrike": 80, "totalPainAtMax": 1284000, "spotDistance": 1.40, "spotDistancePct": 1.72 }
  ],

  "expectedMoves": [
    { "dte": 7, "atmStrike": 81, "lowerBound": 79.20, "upperBound": 83.60, "moveAmount": 2.20, "movePercent": 2.70 }
  ],

  "termStructure": [
    { "dte": 7, "atmIV": 0.2341, "expiration": 1747353600 }
  ],

  "ivSurface": [ /* 2D array of {strike, dte, iv} */ ],

  "topFlow": [
    { "contractSymbol": "NDAQ250516C00085000", "type": "call", "strike": 85, "dte": 7, "volumeOIRatio": 8.42, "iv": 0.3812, "signal": "unusual_volume", "severity": "high" }
  ]
}

GET /api/analytics/snapshot Trader+

Returns a lightweight snapshot of the most important options metrics for a symbol — gamma flip, total GEX, max pain, sentiment, and put/call ratio. Uses only the nearest expiration for speed. Ideal for bots, dashboards, and mobile clients that need key signals without the full overview payload.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol

                
                
                
              
curl "https://greeks.pro/api/analytics/snapshot?symbol=AAPL" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/snapshot?symbol=AAPL',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const snap = await res.json();
console.log(snap.sentiment, snap.gammaFlip);
import requests

snap = requests.get(
    'https://greeks.pro/api/analytics/snapshot',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'AAPL'}
).json()

Response Schema

{
  "symbol":       "AAPL",
  "spotPrice":    213.50,
  "timestamp":    1748390400,
  "gammaFlip":    210.00,   // strike where net GEX = 0
  "totalGEX":     48210000, // positive = stabilizing, negative = amplifying
  "maxPain":      212.50,
  "sentiment":    "bullish", // "bullish" | "bearish" | "neutral"
  "putCallRatio": 0.62
}

GET /api/analytics/levels Trader+

Returns key options-derived price levels — gamma flip, call wall, put wall, max pain, and major strikes with significant open interest. Useful for identifying structural support/resistance levels implied by options positioning.

Parameters

Parameter	Type	Required	Description
symbol	string	Required	Ticker symbol

                
                
                
              
curl "https://greeks.pro/api/analytics/levels?symbol=SPY" \
  -H "X-API-Key: grk_your_key_here"
const res = await fetch(
  'https://greeks.pro/api/analytics/levels?symbol=SPY',
  { headers: { 'X-API-Key': 'grk_your_key_here' } }
);
const lvl = await res.json();
console.log(`Call wall: ${lvl.callWall}, Put wall: ${lvl.putWall}`);
import requests

lvl = requests.get(
    'https://greeks.pro/api/analytics/levels',
    headers={'X-API-Key': 'grk_your_key_here'},
    params={'symbol': 'SPY'}
).json()

Response Schema

{
  "symbol":        "SPY",
  "spotPrice":     582.14,
  "timestamp":     1748390400,
  "gammaFlip":     575.00,   // strike where net GEX = 0
  "callWall":      590.00,   // strike with highest call gamma exposure
  "putWall":       570.00,   // strike with highest (most negative) put GEX
  "maxPain":       580.00,
  "majorStrikes":  [570, 575, 580, 585, 590]  // strikes with significant OI (max 10)
}

GET /api/public/max-pain

Returns max pain for the nearest expiration. No auth required. Rate limited to 10 requests/hour per IP. Response headers include X-RateLimit-Limit and X-RateLimit-Remaining.

Query param: symbol — one of: SPY, QQQ, AAPL, TSLA, NVDA, AMZN, MSFT, META, AMD, GOOGL, IWM, GLD, COIN, PLTR, SOFI

GET /api/public/max-pain?symbol=SPY

{
  "symbol": "SPY",
  "spotPrice": 582.14,
  "expiration": 1774051200,
  "dte": 3,
  "maxPainStrike": 580,
  "maxPainDistancePct": 0.37,
  "timestamp": 1741651234
}

WS /ws/analytics Pro+

Real-time analytics streaming over WebSocket. The server pushes fresh derived data at your configured interval — no polling required. One active session per API key. See the WebSocket Protocol section for the full protocol reference.

Connection URL

wss://greeks.pro/ws/analytics?key=grk_your_key_here

Subscribe Message

{
  "symbol":    "AAPL",        // required
  "interval":  5,             // seconds between pushes (min: 3, default: 5)
  "subscribe": ["overview", "gex", "flow"]  // omit for all streams
}

Real-time

WebSocket Protocol

The analytics WebSocket provides a continuous push feed of derived data. Connect, subscribe, and receive structured JSON messages — no polling loop required.

⚠

One session per API key. Opening a second connection closes the first. If you receive close code 4001, do not attempt to reconnect — another session is already active.

Message Types

All server-to-client messages are JSON objects with a kind field:

kind	When sent	Data field
subscribed	Immediately after successful subscription	Object with `interval` and `streams[]`
overview	Every interval (if subscribed)	Full overview object (same as REST)
greeks	Every interval (if subscribed)	Greeks object
gex	Every interval (if subscribed)	GEX object
flow	Every interval (if subscribed)	Flow signals
maxpain	Every interval (if subscribed)	Max pain results
error	On validation or server error	Error message string

Close Codes

Code	Meaning	Action
1000	Normal close	Safe to reconnect
1001	Server shutdown	Reconnect with backoff
1006	Abnormal / connection lost	Reconnect with backoff
4001	Duplicate session detected	Do NOT reconnect

Full Client Example

class GreeksStream {
  constructor(apiKey, symbol, opts = {}) {
    this.apiKey   = apiKey;
    this.symbol   = symbol;
    this.interval = opts.interval  || 5;
    this.streams  = opts.streams   || ['overview', 'gex', 'flow'];
    this.handlers = {};
    this.ws       = null;
    this._noDuplicate = false;
  }

  on(kind, fn) {
    this.handlers[kind] = fn;
    return this; // chainable
  }

  connect() {
    const url = `wss://greeks.pro/ws/analytics?key=${this.apiKey}`;
    this.ws = new WebSocket(url);

    this.ws.onopen = () => {
      this.ws.send(JSON.stringify({
        symbol:    this.symbol,
        interval:  this.interval,
        subscribe: this.streams
      }));
    };

    this.ws.onmessage = (e) => {
      const msg = JSON.parse(e.data);
      if (this.handlers[msg.kind]) {
        this.handlers[msg.kind](msg.data, msg);
      }
    };

    this.ws.onclose = (e) => {
      if (e.code === 4001) {
        console.warn('Duplicate session — not reconnecting');
        this._noDuplicate = true;
        return;
      }
      // Reconnect with backoff for other close codes
      if (!this._noDuplicate) {
        setTimeout(() => this.connect(), 3000);
      }
    };

    this.ws.onerror = (err) => console.error('WS error', err);
  }

  disconnect() {
    if (this.ws) this.ws.close();
  }
}

// Usage
const stream = new GreeksStream('grk_your_key_here', 'AAPL', {
  interval: 5,
  streams: ['overview', 'gex', 'flow']
});

stream
  .on('subscribed', (data) => console.log('Streaming', data.streams))
  .on('overview',   (data) => updateDashboard(data))
  .on('gex',        (data) => updateGEXChart(data.strikes))
  .on('flow',       (data) => renderFlowTable(data.signals))
  .on('error',      (msg)  => console.error('Server error:', msg))
  .connect();

Errors

Error Codes

All errors return a JSON body: {"error": "message"}. HTTP status codes follow standard conventions.

Status	Meaning	Recommended Action
400	Invalid or missing request parameters	Inspect `error` field and fix request params (e.g. missing `symbol`)
401	Invalid or missing API key	Check the key format (`grk_…`) and redirect user to login if needed
403	Insufficient plan for this endpoint	Show an upgrade prompt — user's plan doesn't include this endpoint
403	Symbol limit reached	User has reached the max tracked symbols for their plan; prompt to upgrade
429	Rate limit exceeded	Read `Retry-After` header and wait that many seconds before retrying
500	Internal server error (data fetch failed)	Retry with exponential backoff — usually a transient data source unavailability

Error Handling Example

            
            
          
async function fetchWithRetry(url, key, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const res = await fetch(url, { headers: { 'X-API-Key': key } });

    if (res.status === 429) {
      const wait = parseInt(res.headers.get('Retry-After') || '60');
      await new Promise(r => setTimeout(r, wait * 1000));
      continue;
    }

    if (res.status === 401) {
      window.location.href = '/login';
      throw new Error('Unauthorized');
    }

    if (res.status === 403) {
      const { error } = await res.json();
      showUpgradePrompt(error);
      throw new Error(error);
    }

    if (res.status >= 500 && attempt < maxRetries - 1) {
      await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 1000));
      continue;
    }

    return res.json();
  }
}
import time, requests

def fetch_with_retry(url, key, max_retries=3):
    for attempt in range(max_retries):
        r = requests.get(url, headers={'X-API-Key': key})

        if r.status_code == 429:
            wait = int(r.headers.get('Retry-After', 60))
            time.sleep(wait)
            continue

        if r.status_code == 403:
            raise PermissionError(r.json()['error'])

        if r.status_code >= 500 and attempt < max_retries - 1:
            time.sleep(2 ** attempt)
            continue

        r.raise_for_status()
        return r.json()

Community & Tools

Discord Bot

Bring institutional-grade options analytics directly to your Discord server. Our bot provides real-time data, GEX, Max Pain, and flow detection via simple slash commands.

Invite Bot to Server Join our Community

Available Commands

Command	Description	Example
/overview <symbol>	Full options dashboard snapshot (Sentiment, GEX, Max Pain, Walls, Regime).	/overview SPY
/gex <symbol>	Gamma Exposure profile, net GEX, Gamma Flip, and top key strikes.	/gex TSLA
/flow <symbol>	Unusual options activity (smart money flow detection).	/flow NVDA
/maxpain <symbol>	Max Pain levels and spot distance for upcoming expirations.	/maxpain AAPL
/greeks <symbol>	Top option contract Greeks in the ATM range.	/greeks AMZN

Pro+ Feature

Discord Alerts

Configure alerts that watch analytics signals for any supported symbol and fire a Discord webhook when your conditions are met. Available on Pro (5 alerts) and Institutional (unlimited).

⚠

Pro plan or higher required. Alerts are not available on Free or Trader plans. Upgrade to Pro to get started.

How it works

The alert engine runs inside the backend process and polls all enabled alerts every 60 seconds. For each unique symbol it fetches one analytics snapshot, evaluates every alert's conditions against it, and fires the Discord webhook for any alert whose conditions are met and whose cooldown has expired. All state (last_fired_at, fire_count_today, full history) is persisted in the database — a server restart will never re-trigger a stale alert.

HTTP API

Method	Route	Description
GET	/api/alerts	List your alerts
POST	/api/alerts	Create an alert
PUT	/api/alerts/:id	Update an alert
DELETE	/api/alerts/:id	Delete an alert and its history
PATCH	/api/alerts/:id/toggle	Enable or disable without a full edit
POST	/api/alerts/:id/test	Fire webhook immediately — bypasses cooldown and conditions
GET	/api/alerts/:id/history	Last 50 delivery history entries
POST	/api/alerts/:id/duplicate	Clone an alert (counts toward plan limit)
POST	/api/alerts/:id/snooze	Pause an alert — body `{"hours": 4}`; `0` to unsnooze

Alert object

{
  "id":               "uuid",
  "name":             "SPY Gamma Flip Alert",
  "symbol":           "SPY",
  "enabled":          true,
  "logic":            "AND",          // "AND" | "OR"
  "conditions":          [...],
  "webhooks":             [
    {
      "url":              "https://discord.com/api/webhooks/...",
      "use_rich_embed":  true,
      "message_template": ""
    }
  ],
  "cooldown_minutes":    30,
  "max_fires_per_day":  0,            // 0 = unlimited
  "market_hours_only":  false,        // skip outside NYSE hours
  "snoozed_until":      null,         // ISO timestamp or null
  "last_fired_at":      "2026-03-12T03:08:00Z",
  "fire_count_today":   1,
  "created_at":         "2026-03-11T20:00:00Z"
}

Validation rules

Field	Rule
symbol	Non-empty, uppercase, must be a supported ticker
logic	`AND` or `OR`
conditions	1–20 items; each must have a valid `type` and all required params
webhooks	Array of webhook objects; each `url` must start with `https://discord.com/api/webhooks/`. Falls back to legacy `webhook_url` if omitted.
webhooks[].use_rich_embed	If `true`, sends a Discord embed with price/GEX fields instead of a plain text message
webhooks[].message_template	Optional. Overrides the default message. Supports `{{symbol}}`, `{{spot_price}}`, `{{alert_name}}`, `{{fired_at}}`, `{{conditions_met}}`
cooldown_minutes	5–1440 (5 minutes to 24 hours)
max_fires_per_day	Daily fire cap. `0` = unlimited
market_hours_only	If `true`, alert only fires during NYSE hours (9:30–16:00 ET, Mon–Fri)
plan limit	HTTP 403 if you already have MaxAlerts configured (`5` on Pro)

Discord Alerts

Condition Types

Each condition in the conditions array is a JSON object with a type field plus type-specific parameters. Conditions are evaluated against the latest analytics snapshot for the alert's symbol.

Price / Spot

type	Parameters	Description
spot_crosses_level	`direction` above/below, `value` float	Spot crosses a fixed price level
spot_pct_change	`direction` up/down, `value` %, `window_minutes` int	Spot moved X% in last N minutes
spot_vs_gamma_flip	`direction` above/below	Spot crosses the Gamma Flip strike
gamma_flip_distance_pct	`operator` lt/gt, `value` %	Spot is within X% of Gamma Flip

GEX / Gamma

type	Parameters	Description
gex_sign_change	`to` positive/negative	Net GEX changes sign
gex_below_threshold	`value` float (billions)	Net GEX below X billion
gex_pct_change	`direction` up/down, `value` %, `window_minutes` int	Net GEX changed X% in N minutes
delta_exposure_crosses	`direction` above/below, `value` float	Net DEX crosses threshold
vega_exposure_crosses	`direction` above/below, `value` float	Total vega exposure crosses threshold

Max Pain

type	Parameters	Description
max_pain_distance_pct	`operator` lt/gt, `value` %	Spot-to-MaxPain distance less or greater than X%
max_pain_strike_change	none	Max Pain strike changes (repositioning detected)

Volatility

type	Parameters	Description
iv_atm_crosses	`direction` above/below, `value` %	ATM IV of nearest expiry crosses X%
iv_spike	`pct_change` %, `window_minutes` int	ATM IV spiked X% in N minutes
skew_crosses	`direction`, `value` %, `dte` int	25-delta skew (put IV − call IV) crosses X%
term_structure_inversion	`dte_near` int, `dte_far` int	IV at near DTE greater than IV at far DTE (backwardation)
expected_move_pct_crosses	`direction`, `value` %, `dte` int	Expected move % for DTE crosses X%

Flow / Positioning

type	Parameters	Description
flow_signal	`contract_type` call/put/any, `severity` high/medium/any, `min_vol_oi_ratio` float	Unusual flow signal detected
multiple_flow_signals	`min_count` int, `window_minutes` int, `severity`	N+ flow signals in X minutes
put_call_ratio_crosses	`direction` above/below, `value` float	P/C volume ratio crosses threshold
oi_change_pct	`operator` gt/lt, `value` %, `contract_type` call/put/net	OI changed X% (new positioning detected)

Walls / Levels

type	Parameters	Description
call_wall_distance_pct	`operator` lt/gt, `value` %	Spot distance from Call Wall
put_wall_distance_pct	`operator` lt/gt, `value` %	Spot distance from Put Wall
call_put_wall_compression	`max_range_pct` %	Distance between Call and Put Walls less than X% of spot

Example condition object

// Spot crosses above $500
{ "type": "spot_crosses_level", "direction": "above", "value": 500 }

// Net GEX turns negative
{ "type": "gex_sign_change", "to": "negative" }

// ATM IV spikes more than 10% in the last 30 minutes
{ "type": "iv_spike", "pct_change": 10, "window_minutes": 30 }

// Spot is within 1% of the Gamma Flip
{ "type": "gamma_flip_distance_pct", "operator": "lt", "value": 1 }

Discord Alerts

Message Template

The message_template field supports dynamic variables using {{variable}} syntax. When an alert fires, each variable is replaced with the live value from the analytics snapshot. Unknown variables are replaced with an empty string.

Available variables

Variable	Description	Example
{{symbol}}	Ticker symbol	SPY
{{spot_price}}	Current spot price	563.42
{{gamma_flip}}	Gamma Flip strike	560.00
{{net_gex}}	Net GEX in billions	+$2.14B
{{max_pain}}	Max Pain strike	558
{{put_call_ratio}}	P/C volume ratio	0.82
{{atm_iv}}	ATM implied volatility	18.4%
{{call_wall}}	Call Wall strike	570.00
{{put_wall}}	Put Wall strike	550.00
{{sentiment}}	Overall market sentiment	BULLISH
{{expected_move_pct}}	Expected move as % of spot	1.8%
{{fired_at}}	Time the alert fired (UTC)	03:08 UTC
{{conditions_met}}	List of conditions that evaluated true	spot_crosses_level(above)
{{alert_name}}	Name of the alert	SPY Gamma Flip Alert

Rich embed vs plain text

Each webhook in the webhooks array has its own use_rich_embed flag. When true, the engine sends a formatted Discord embed card with fields for Symbol, Spot Price, Gamma Flip, Net GEX, Max Pain, Sentiment, and Conditions Triggered — plus your message_template rendered as the content field above the embed. When false, only the rendered template text is sent as plain content. You can mix rich and plain webhooks within the same alert (e.g., one channel gets a rich embed, another gets a plain message).

Example template

[{{symbol}}] Alert: {{alert_name}}

Spot: {{spot_price}} | Sentiment: {{sentiment}}
Gamma Flip: {{gamma_flip}} | Net GEX: {{net_gex}}
Max Pain: {{max_pain}} | Expected Move: {{expected_move_pct}}
Call Wall: {{call_wall}} | Put Wall: {{put_wall}}
P/C Ratio: {{put_call_ratio}} | ATM IV: {{atm_iv}}

Conditions: {{conditions_met}}
Fired at: {{fired_at}}

Example Discord embed payload

{
  "content": "[SPY] Alert: Gamma Flip Alert\n\nSpot: 563.42 | Sentiment: BEARISH\n...",
  "embeds": [{
    "title": "[ALERT] Gamma Flip Alert",
    "color": 15158332,
    "fields": [
      { "name": "Symbol",     "value": "SPY",      "inline": true },
      { "name": "Spot Price", "value": "$563.42", "inline": true },
      { "name": "Gamma Flip", "value": "$560.00", "inline": true },
      { "name": "Net GEX",    "value": "-$1.76B", "inline": true },
      { "name": "Max Pain",   "value": "$558",    "inline": true },
      { "name": "Sentiment",  "value": "BEARISH", "inline": true },
      { "name": "Conditions Triggered", "value": "spot_vs_gamma_flip(below)", "inline": false }
    ],
    "footer":    { "text": "greeks.pro" },
    "timestamp": "2026-03-12T03:08:00Z"
  }]
}

i

Embed color is green for bullish conditions, red for bearish, and blue for neutral/informational. Determined automatically from the sentiment field of the snapshot.

Pricing

Plans & Limits

Each plan unlocks progressively more endpoints and higher rate limits. All plans can access any supported US stock or ETF ticker symbol.

	Free	Trader	Pro	Institutional
Requests / min	10	60	300	1,000
Requests / day	600	5,000	50,000	Unlimited
Max Pain	✓	✓	✓	✓
Greeks	—	✓	✓	✓
GEX / DEX	—	✓	✓	✓
Unusual Flow	—	✓	✓	✓
Full Overview	—	—	✓	✓
WebSocket Stream	—	—	✓	✓
SLA / Priority Support	—	—	—	✓

View Pricing & Upgrade

Reference

Supported Assets

All 68 assets below are verified against our live data source and return valid options chains. Every symbol can be used as the symbol parameter in any API endpoint.

Coverage verified — each ticker is tested against Yahoo Finance on a rolling basis. Data includes options chains, spot price, Greeks, GEX, max pain, and unusual flow. Tickers are denominated in USD.

Index & Broad Market ETFs

SPYS&P 500 ETF

QQQNasdaq 100 ETF

IWMRussell 2000 ETF

DIADow Jones ETF

VOOVanguard S&P 500

VTITotal Market ETF

Mega Cap & Technology

AAPLApple

MSFTMicrosoft

NVDANVIDIA

GOOGLAlphabet

AMZNAmazon

METAMeta

TSLATesla

NFLXNetflix

AVGOBroadcom

AMDAMD

Financials

JPMJPMorgan Chase

GSGoldman Sachs

MSMorgan Stanley

BACBank of America

VVisa

MAMastercard

CCitigroup

WFCWells Fargo

Energy

XOMExxonMobil

CVXChevron

COPConocoPhillips

OXYOccidental

SLBSLB

XLEEnergy Sector ETF

Healthcare & Biotech

JNJJohnson & Johnson

UNHUnitedHealth

PFEPfizer

LLYEli Lilly

ABBVAbbVie

MRNAModerna

XBIBiotech ETF

Industrials & Defense

BABoeing

CATCaterpillar

GEGE Aerospace

LMTLockheed Martin

RTXRTX Corp

HONHoneywell

Retail & Consumer

WMTWalmart

COSTCostco

HDHome Depot

TGTTarget

NKENike

SBUXStarbucks

MCDMcDonald's

ETFs — Fixed Income, Commodities & Sectors

TLT20yr Treasury ETF

GLDGold ETF

SLVSilver ETF

HYGHigh Yield Bond ETF

LQDCorp Bond ETF

EEMEmerging Markets ETF

XLKTech Sector ETF

XLFFinancial Sector ETF

Cloud, Growth & Crypto-Adjacent

CRMSalesforce

PLTRPalantir

SNOWSnowflake

NETCloudflare

DDOGDatadog

CRWDCrowdStrike

COINCoinbase

MSTRMicroStrategy

SOFISoFi Technologies

UBERUber

ℹ

Need a ticker not listed here?
Contact us at greeks.pro/contact — any US-listed equity or ETF with liquid options can be added on request.

Greeks Analytics API

What you can build

Common Parameters

Authentication

Methods

Rate Limits & Quotas

Response Headers

Plan Limits

Endpoints

Embeddable Widget

WebSocket Protocol

Message Types

Close Codes

Full Client Example

Error Codes

Error Handling Example

Discord Bot

Available Commands

Discord Alerts

How it works

HTTP API

Alert object

Validation rules

Condition Types

Price / Spot

GEX / Gamma

Max Pain

Volatility

Flow / Positioning

Walls / Levels

Example condition object

Message Template

Available variables

Rich embed vs plain text

Example template

Example Discord embed payload

Plans & Limits

Supported Assets