FlashAlpha Lab API: Real-Time Options Exposure Analytics

# Free tier: single-expiry GEX on any US equity
curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/AAPL?expiration=2026-06-19"

import requests

API_KEY = "YOUR_API_KEY"
BASE    = "https://lab.flashalpha.com"
headers = {"X-Api-Key": API_KEY}

# 1. Single-expiry gamma exposure (Free tier, any equity)
gex = requests.get(
    f"{BASE}/v1/exposure/gex/AAPL?expiration=2026-06-19",
    headers=headers
).json()

print(f"Net GEX:    ${gex['net_gex']:,.0f}")
print(f"Gamma Flip: {gex['gamma_flip']}")

# 2. Key support/resistance levels (Free tier, any equity)
levels = requests.get(
    f"{BASE}/v1/exposure/levels/AAPL",
    headers=headers
).json()["levels"]

print(f"Call Wall:  {levels['call_wall']}")
print(f"Put Wall:   {levels['put_wall']}")

# Full regime + dealer-hedging summary is /v1/exposure/summary (Growth);
# ETF/index symbols and full-chain GEX start at Basic/Growth.

const API_KEY = "YOUR_API_KEY";
const BASE    = "https://lab.flashalpha.com";

const headers = { "X-Api-Key": API_KEY };

// 1. Single-expiry gamma exposure (Free tier, any equity)
const gex = await fetch(`${BASE}/v1/exposure/gex/AAPL?expiration=2026-06-19`, { headers })
  .then(r => r.json());

console.log(`Net GEX:    $${gex.net_gex.toLocaleString()}`);
console.log(`Gamma Flip: ${gex.gamma_flip}`);

// 2. Key support/resistance levels (Free tier, any equity)
const { levels } = await fetch(`${BASE}/v1/exposure/levels/AAPL`, { headers })
  .then(r => r.json());

console.log(`Call Wall:  ${levels.call_wall}`);
console.log(`Put Wall:   ${levels.put_wall}`);

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");
var baseUrl = "https://lab.flashalpha.com";

// 1. Single-expiry gamma exposure (Free tier, any equity)
var gex = JsonDocument.Parse(
    await client.GetStringAsync($"{baseUrl}/v1/exposure/gex/AAPL?expiration=2026-06-19")
).RootElement;

Console.WriteLine($"Net GEX:    {gex.GetProperty("net_gex")}");
Console.WriteLine($"Gamma Flip: {gex.GetProperty("gamma_flip")}");

// 2. Key support/resistance levels (Free tier, any equity)
var levels = JsonDocument.Parse(
    await client.GetStringAsync($"{baseUrl}/v1/exposure/levels/AAPL")
).RootElement.GetProperty("levels");

Console.WriteLine($"Call Wall:  {levels.GetProperty("call_wall")}");

HttpClient client = HttpClient.newHttpClient();
String BASE = "https://lab.flashalpha.com";
String API_KEY = "YOUR_API_KEY";

// 1. Single-expiry gamma exposure (Free tier, any equity)
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/v1/exposure/gex/AAPL?expiration=2026-06-19"))
    .header("X-Api-Key", API_KEY).build();

JsonObject gex = JsonParser.parseString(
    client.send(req, BodyHandlers.ofString()).body()
).getAsJsonObject();

System.out.println("Net GEX:    " + gex.get("net_gex"));
System.out.println("Gamma Flip: " + gex.get("gamma_flip"));

base := "https://lab.flashalpha.com"
apiKey := "YOUR_API_KEY"

// 1. Single-expiry gamma exposure (Free tier, any equity)
req, _ := http.NewRequest("GET", base+"/v1/exposure/gex/AAPL?expiration=2026-06-19", nil)
req.Header.Set("X-Api-Key", apiKey)
resp, _ := http.DefaultClient.Do(req)

var gex map[string]interface{}
json.NewDecoder(resp.Body).Decode(&gex)
resp.Body.Close()

fmt.Printf("Net GEX:    %v\n", gex["net_gex"])
fmt.Printf("Gamma Flip: %v\n", gex["gamma_flip"])

import requests, os

API_KEY = os.environ["FLASHALPHA_API_KEY"]
BASE    = "https://lab.flashalpha.com"
HEADERS = {"X-Api-Key": API_KEY}

def fa_get(path, params=None):
    """Reusable helper for FlashAlpha API calls."""
    resp = requests.get(f"{BASE}{path}", headers=HEADERS, params=params)
    resp.raise_for_status()
    return resp.json()

# Usage
summary = fa_get("/v1/exposure/summary/SPY")
quote   = fa_get("/stockquote/SPY")

const API_KEY = process.env.FLASHALPHA_API_KEY;
const BASE    = "https://lab.flashalpha.com";
const HEADERS = { "X-Api-Key": API_KEY };

async function faGet(path, params = {}) {
  const url = new URL(`${BASE}${path}`);
  Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
  const resp = await fetch(url, { headers: HEADERS });
  if (!resp.ok) throw new Error(`${resp.status}: ${await resp.text()}`);
  return resp.json();
}

// Usage
const summary = await faGet("/v1/exposure/summary/SPY");
const quote   = await faGet("/stockquote/SPY");

using System.Text.Json;

var apiKey = Environment.GetEnvironmentVariable("FLASHALPHA_API_KEY");
var baseUrl = "https://lab.flashalpha.com";
var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", apiKey);

async Task<JsonElement> FaGet(string path)
{
    var json = await client.GetStringAsync($"{baseUrl}{path}");
    return JsonDocument.Parse(json).RootElement;
}

// Usage
var summary = await FaGet("/v1/exposure/summary/SPY");
var quote   = await FaGet("/stockquote/SPY");

String API_KEY = System.getenv("FLASHALPHA_API_KEY");
String BASE = "https://lab.flashalpha.com";
HttpClient client = HttpClient.newHttpClient();

JsonObject faGet(String path) throws Exception {
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create(BASE + path))
        .header("X-Api-Key", API_KEY).build();
    String body = client.send(req, BodyHandlers.ofString()).body();
    return JsonParser.parseString(body).getAsJsonObject();
}

// Usage
JsonObject summary = faGet("/v1/exposure/summary/SPY");
JsonObject quote   = faGet("/stockquote/SPY");

apiKey := os.Getenv("FLASHALPHA_API_KEY")
base   := "https://lab.flashalpha.com"

func faGet(path string) (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", base+path, nil)
    req.Header.Set("X-Api-Key", apiKey)
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

// Usage
summary, _ := faGet("/v1/exposure/summary/SPY")
quote, _   := faGet("/stockquote/SPY")

# Set your API key
export FLASHALPHA_API_KEY="YOUR_API_KEY"

# Reusable function
fa_get() {
  curl -s -H "X-Api-Key: $FLASHALPHA_API_KEY" \
    "https://lab.flashalpha.com$1"
}

# Usage
fa_get /v1/exposure/summary/SPY | jq .
fa_get /stockquote/SPY | jq .

import time, requests

def fa_get_safe(path, params=None):
    resp = requests.get(f"{BASE}{path}", headers=HEADERS, params=params)

    # Check remaining quota
    remaining = resp.headers.get("X-RateLimit-Remaining")
    if remaining and int(remaining) < 10:
        print(f"Warning: only {remaining} requests remaining today")

    if resp.status_code == 429:
        retry_after = int(resp.headers.get("Retry-After", 60))
        print(f"Rate limited. Retrying in {retry_after}s...")
        time.sleep(retry_after)
        return fa_get_safe(path, params)  # retry once

    resp.raise_for_status()
    return resp.json()

async function faGetSafe(path, params = {}) {
  const url = new URL(`${BASE}${path}`);
  Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
  const resp = await fetch(url, { headers: HEADERS });

  // Check remaining quota
  const remaining = resp.headers.get("X-RateLimit-Remaining");
  if (remaining && parseInt(remaining) < 10) {
    console.warn(`Warning: only ${remaining} requests remaining today`);
  }

  if (resp.status === 429) {
    const retryAfter = parseInt(resp.headers.get("Retry-After") || "60");
    console.log(`Rate limited. Retrying in ${retryAfter}s...`);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return faGetSafe(path, params); // retry once
  }

  if (!resp.ok) throw new Error(`${resp.status}: ${await resp.text()}`);
  return resp.json();
}

async Task<JsonElement> FaGetSafe(string path)
{
    var resp = await client.GetAsync($"{baseUrl}{path}");

    // Check remaining quota
    if (resp.Headers.TryGetValues("X-RateLimit-Remaining", out var vals))
    {
        var remaining = int.Parse(vals.First());
        if (remaining < 10)
            Console.WriteLine($"Warning: only {remaining} requests remaining today");
    }

    if (resp.StatusCode == (HttpStatusCode)429)
    {
        var retryAfter = int.Parse(
            resp.Headers.GetValues("Retry-After").FirstOrDefault() ?? "60");
        Console.WriteLine($"Rate limited. Retrying in {retryAfter}s...");
        await Task.Delay(retryAfter * 1000);
        return await FaGetSafe(path); // retry once
    }

    resp.EnsureSuccessStatusCode();
    var json = await resp.Content.ReadAsStringAsync();
    return JsonDocument.Parse(json).RootElement;
}

JsonObject faGetSafe(String path) throws Exception {
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create(BASE + path))
        .header("X-Api-Key", API_KEY).build();
    HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());

    // Check remaining quota
    resp.headers().firstValue("X-RateLimit-Remaining").ifPresent(r -> {
        if (Integer.parseInt(r) < 10)
            System.out.println("Warning: only " + r + " requests remaining today");
    });

    if (resp.statusCode() == 429) {
        int retryAfter = Integer.parseInt(
            resp.headers().firstValue("Retry-After").orElse("60"));
        System.out.println("Rate limited. Retrying in " + retryAfter + "s...");
        Thread.sleep(retryAfter * 1000L);
        return faGetSafe(path); // retry once
    }

    return JsonParser.parseString(resp.body()).getAsJsonObject();
}

func faGetSafe(path string) (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", base+path, nil)
    req.Header.Set("X-Api-Key", apiKey)
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()

    // Check remaining quota
    if r := resp.Header.Get("X-RateLimit-Remaining"); r != "" {
        if remaining, _ := strconv.Atoi(r); remaining < 10 {
            fmt.Printf("Warning: only %d requests remaining today\n", remaining)
        }
    }

    if resp.StatusCode == 429 {
        retryAfter, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
        if retryAfter == 0 { retryAfter = 60 }
        fmt.Printf("Rate limited. Retrying in %ds...\n", retryAfter)
        time.Sleep(time.Duration(retryAfter) * time.Second)
        return faGetSafe(path) // retry once
    }

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

# Check rate limit headers with verbose output
curl -v -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/SPY" 2>&1 | \
  grep -i "x-ratelimit\|retry-after"

# Retry after rate limit (bash)
resp=$(curl -s -w "\n%{http_code}" -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/SPY")
code=$(echo "$resp" | tail -1)
if [ "$code" = "429" ]; then
  echo "Rate limited  -  waiting 60s..."
  sleep 60
fi

resp = requests.get(f"{BASE}/v1/exposure/gex/INVALID", headers=HEADERS)

if resp.status_code == 200:
    data = resp.json()
elif resp.status_code == 401:
    print("Bad API key  -  check your X-Api-Key header")
elif resp.status_code == 403:
    err = resp.json()
    print(f"Tier restricted: {err['message']}")
    print(f"Current plan: {err['current_plan']}, required: {err['required_plan']}")
elif resp.status_code == 404:
    err = resp.json()
    print(f"Not found: {err['message']}")  # "No data for INVALID."
elif resp.status_code == 429:
    err = resp.json()
    print(f"Quota exceeded on {err['current_plan']} plan")
    print(f"Resets at: {err['reset_at']}")
else:
    print(f"Unexpected error: {resp.status_code}")

const resp = await fetch(`${BASE}/v1/exposure/gex/INVALID`, { headers: HEADERS });

switch (resp.status) {
  case 200:
    const data = await resp.json();
    break;
  case 401:
    console.error("Bad API key  -  check your X-Api-Key header");
    break;
  case 403:
    const err403 = await resp.json();
    console.error(`Tier restricted: ${err403.message}`);
    console.error(`Current: ${err403.current_plan}, required: ${err403.required_plan}`);
    break;
  case 404:
    const err404 = await resp.json();
    console.error(`Not found: ${err404.message}`);
    break;
  case 429:
    const err429 = await resp.json();
    console.error(`Quota exceeded on ${err429.current_plan} plan`);
    console.error(`Resets at: ${err429.reset_at}`);
    break;
  default:
    console.error(`Unexpected error: ${resp.status}`);
}

var resp = await client.GetAsync($"{baseUrl}/v1/exposure/gex/INVALID");
var body = await resp.Content.ReadAsStringAsync();

switch ((int)resp.StatusCode)
{
    case 200:
        var data = JsonDocument.Parse(body).RootElement;
        break;
    case 401:
        Console.WriteLine("Bad API key  -  check your X-Api-Key header");
        break;
    case 403:
        var err403 = JsonDocument.Parse(body).RootElement;
        Console.WriteLine($"Tier restricted: {err403.GetProperty("message")}");
        Console.WriteLine($"Current: {err403.GetProperty("current_plan")}, required: {err403.GetProperty("required_plan")}");
        break;
    case 404:
        var err404 = JsonDocument.Parse(body).RootElement;
        Console.WriteLine($"Not found: {err404.GetProperty("message")}");
        break;
    case 429:
        var err429 = JsonDocument.Parse(body).RootElement;
        Console.WriteLine($"Quota exceeded on {err429.GetProperty("current_plan")} plan");
        Console.WriteLine($"Resets at: {err429.GetProperty("reset_at")}");
        break;
    default:
        Console.WriteLine($"Unexpected error: {(int)resp.StatusCode}");
        break;
}

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/v1/exposure/gex/INVALID"))
    .header("X-Api-Key", API_KEY).build();
HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());

switch (resp.statusCode()) {
    case 200:
        JsonObject data = JsonParser.parseString(resp.body()).getAsJsonObject();
        break;
    case 401:
        System.out.println("Bad API key  -  check your X-Api-Key header");
        break;
    case 403:
        JsonObject err403 = JsonParser.parseString(resp.body()).getAsJsonObject();
        System.out.println("Tier restricted: " + err403.get("message"));
        break;
    case 404:
        JsonObject err404 = JsonParser.parseString(resp.body()).getAsJsonObject();
        System.out.println("Not found: " + err404.get("message"));
        break;
    case 429:
        JsonObject err429 = JsonParser.parseString(resp.body()).getAsJsonObject();
        System.out.println("Quota exceeded on " + err429.get("current_plan") + " plan");
        break;
    default:
        System.out.println("Unexpected error: " + resp.statusCode());
}

req, _ := http.NewRequest("GET", base+"/v1/exposure/gex/INVALID", nil)
req.Header.Set("X-Api-Key", apiKey)
resp, _ := http.DefaultClient.Do(req)
body, _ := io.ReadAll(resp.Body)
resp.Body.Close()

switch resp.StatusCode {
case 200:
    var data map[string]interface{}
    json.Unmarshal(body, &data)
case 401:
    fmt.Println("Bad API key  -  check your X-Api-Key header")
case 403:
    var err map[string]interface{}
    json.Unmarshal(body, &err)
    fmt.Printf("Tier restricted: %v\n", err["message"])
case 404:
    var err map[string]interface{}
    json.Unmarshal(body, &err)
    fmt.Printf("Not found: %v\n", err["message"])
case 429:
    var err map[string]interface{}
    json.Unmarshal(body, &err)
    fmt.Printf("Quota exceeded on %v plan\n", err["current_plan"])
default:
    fmt.Printf("Unexpected error: %d\n", resp.StatusCode)
}

# Check HTTP status code with curl
resp=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/INVALID")

echo "Status: $resp"

# Get full error body
curl -s -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/INVALID" | jq .