FlashAlpha

https://flashalpha.com/docs/
Admin
FlashAlpha is an API platform providing real-time and historical market data, options analytics, and...
Tokens:132,411
Snippets:963
Trust Score:5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Go Screener Example

Source: https://flashalpha.com/docs/lab-api-screener

Initialize the FlashAlpha Go client and make a `Screener` request. Use `go get github.com/FlashAlpha-lab/flashalpha-go` to install.

```go
import (
    "context"
    flashalpha "github.com/FlashAlpha-lab/flashalpha-go"
)

client := flashalpha.NewClient("YOUR_API_KEY")
ctx := context.Background()

result, _ := client.Screener(ctx, flashalpha.ScreenerRequest{
    Filters: flashalpha.ScreenerGroup{
        Op: "and",
        Conditions: []interface{}{
            flashalpha.ScreenerLeaf{Field: "regime",        Operator: "eq",  Value: "positive_gamma"},
            flashalpha.ScreenerLeaf{Field: "harvest_score", Operator: "gte", Value: 65},
        },
    },
    Sort:   []flashalpha.ScreenerSort{{Field: "harvest_score", Direction: "desc"}},
    Select: []string{"symbol", "price", "harvest_score", "dealer_flow_risk"},
})
```

--------------------------------

### Quick Start Example

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

A basic example demonstrating how to use the FlashAlphaClient to fetch GEX and Exposure Levels data.

```APIDOC
## Quick start

Here's a simple example to get you started with the SDK:

```csharp
using FlashAlpha;

// Initialize the client with your API key
using var client = new FlashAlphaClient("YOUR_API_KEY");

// Fetch GEX data for a given symbol
var gex = await client.GexAsync("SPY");
Console.WriteLine($"Net GEX: {gex.GetProperty("net_gex").GetDouble():N0}");
Console.WriteLine($"Flip:    {gex.GetProperty("gamma_flip").GetDouble()}");

// Fetch key support and resistance levels
var key = (await client.ExposureLevelsAsync("SPY")).GetProperty("levels");
Console.WriteLine($"Call wall: {key.GetProperty("call_wall").GetDouble()}");
Console.WriteLine($"Put wall:  {key.GetProperty("put_wall").GetDouble()}");

// Calculate BSM greeks for a specific option contract
var g = await client.GreeksAsync(
    spot: 655,
    strike: 660,
    dte: 7,
    sigma: 0.18,
    type: "call"
);
Console.WriteLine($"delta={g.GetProperty("delta").GetDouble()}");
```

**Note:** All methods return `System.Text.Json.JsonElement`. You can navigate the JSON response using `GetProperty()` and `EnumerateArray()`, or deserialize it into your own C# records using `Deserialize<T>()`.
```

--------------------------------

### Install FlashAlpha Go SDK

Source: https://flashalpha.com/docs/lab-api-sdk-go

Use `go get` to install the latest version of the SDK. Ensure you are using Go 1.21+.

```go
go get github.com/FlashAlpha-lab/flashalpha-go@latest
```

--------------------------------

### Quick Start: Initialize and Use FlashAlpha SDK

Source: https://flashalpha.com/docs/lab-api-sdk-javascript

Initialize the SDK with your API key and make calls to various endpoints. Examples include fetching gamma exposure, key support/resistance levels, BSM Greeks, and account plan usage.

```javascript
import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_API_KEY');

// Gamma exposure for SPY
const gex = await fa.gex('SPY');
console.log(gex.net_gex, gex.gamma_flip);

// Key support / resistance levels
const { levels } = await fa.exposureLevels('SPY');
console.log(levels.call_wall, levels.put_wall);

// BSM greeks for a single contract
const g = await fa.greeks({ spot: 655, strike: 660, dte: 7, sigma: 0.18, type: 'call' });
console.log(g.delta, g.gamma, g.theta);

// Plan & quota usage
console.log(await fa.account());
```

--------------------------------

### Live Options Screener

Source: https://flashalpha.com/docs/lab-api-sdk-python

Demonstrates how to use the live options screener with custom filters, sorting, and selection criteria. This example shows how to find harvestable VRP setups.

```APIDOC
## Live options screener

Screen the live universe by stock-, expiry-, strike-, or contract-level fields. On Alpha tier you get formulas and harvest scores.
```python
# Harvestable VRP setups (Alpha tier)
result = fa.screener(
    filters={
        "op": "and",
        "conditions": [
            {"field": "regime",           "operator": "eq",  "value": "positive_gamma"},
            {"field": "vrp_regime",       "operator": "eq",  "value": "harvestable"},
            {"field": "dealer_flow_risk", "operator": "lte", "value": 40},
            {"field": "harvest_score",    "operator": "gte", "value": 65},
        ],
    },
    sort=[{"field": "harvest_score", "direction": "desc"}],
    select=["symbol", "price", "harvest_score", "dealer_flow_risk", "vrp_regime"],
)

for row in result["data"]:
    print(row["symbol"], row["harvest_score"])
```
```

--------------------------------

### Python Screener Example

Source: https://flashalpha.com/docs/lab-api-screener

Use the `screener` method from the FlashAlpha SDK to query data. Ensure you have installed the SDK using `pip install flashalpha`.

```python
from flashalpha import FlashAlpha
fa = FlashAlpha("YOUR_API_KEY")

result = fa.screener(
    filters={
        "op": "and",
        "conditions": [
            {"field": "regime",        "operator": "eq",  "value": "positive_gamma"},
            {"field": "harvest_score", "operator": "gte", "value": 65},
        ],
    },
    sort=[{"field": "harvest_score", "direction": "desc"}],
    select=["symbol", "price", "harvest_score", "dealer_flow_risk"],
)
for row in result["data"]:
    print(row["symbol"], row["harvest_score"])
```

--------------------------------

### Installation

Source: https://flashalpha.com/docs/lab-api-sdk-python

Install the FlashAlpha Python SDK using pip. Requires Python 3.10 or newer.

```APIDOC
## Install

```
pip install flashalpha
```

Requires Python 3.10 or newer.
```

--------------------------------

### Kotlin Example for getGex

Source: https://flashalpha.com/docs/lab-api-sdk-java

Example of how to use the `gex` method in Kotlin using coroutines.

```APIDOC
## Kotlin Example for getGex

### Description
Example of how to use the `gex` method in Kotlin using coroutines.

### Method Signature
`suspend fun getGex(symbol: String): JsonObject`

### Parameters
- **symbol** (String) - Required - The stock symbol.

### Request Example
```kotlin
import com.flashalpha.FlashAlphaClient
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

val fa = FlashAlphaClient("YOUR_API_KEY")

suspend fun getGex(symbol: String) = withContext(Dispatchers.IO) {
    fa.gex(symbol)
}
```

### Response
- **JsonObject** - Contains the exposure data.
```

--------------------------------

### JavaScript Screener Example

Source: https://flashalpha.com/docs/lab-api-screener

Utilize the `screener` method from the FlashAlpha JavaScript SDK. Install with `npm i flashalpha`.

```javascript
import { FlashAlpha } from 'flashalpha';
const fa = new FlashAlpha('YOUR_API_KEY');

const { data } = await fa.screener({
  filters: {
    op: 'and',
    conditions: [
      { field: 'regime',        operator: 'eq',  value: 'positive_gamma' },
      { field: 'harvest_score', operator: 'gte', value: 65 },
    ],
  },
  sort:   [{ field: 'harvest_score', direction: 'desc' }],
  select: ['symbol', 'price', 'harvest_score', 'dealer_flow_risk'],
});
data.forEach(r => console.log(r.symbol, r.harvest_score));
```

--------------------------------

### Install FlashAlpha Python SDK

Source: https://flashalpha.com/docs/lab-api-sdk-python

Install the SDK using pip. Requires Python 3.10 or newer.

```bash
pip install flashalpha
```

--------------------------------

### Simple Stock Filter Example

Source: https://flashalpha.com/docs/lab-api-screener

A basic query example demonstrating how to filter stocks by 'regime', sort by 'net_gex' in descending order, and select specific fields.

```json
{
  "filters": { "field": "regime", "operator": "eq", "value": "positive_gamma" },
  "sort":    [{ "field": "net_gex", "direction": "desc" }],
  "select":  ["symbol", "price", "regime", "net_gex"]
}
```

--------------------------------

### Screener Method (SDK Examples)

Source: https://flashalpha.com/docs/lab-api-screener

Examples of how to use the `screener()` method from the FlashAlpha SDKs in Python, JavaScript, .NET, Java, and Go.

```APIDOC
## Screener Method (SDK Examples)

This section provides examples of how to use the `screener()` method from the FlashAlpha SDKs in various programming languages.

### Python
```python
from flashalpha import FlashAlpha
fa = FlashAlpha("YOUR_API_KEY")

result = fa.screener(
    filters={
        "op": "and",
        "conditions": [
            {"field": "regime",        "operator": "eq",  "value": "positive_gamma"},
            {"field": "harvest_score", "operator": "gte", "value": 65},
        ],
    },
    sort=[{"field": "harvest_score", "direction": "desc"}],
    select=["symbol", "price", "harvest_score", "dealer_flow_risk"],
)
for row in result["data"]:
    print(row["symbol"], row["harvest_score"])
```

### JavaScript
```javascript
import { FlashAlpha } from 'flashalpha';
const fa = new FlashAlpha('YOUR_API_KEY');

const { data } = await fa.screener({
  filters: {
    op: 'and',
    conditions: [
      { field: 'regime',        operator: 'eq',  value: 'positive_gamma' },
      { field: 'harvest_score', operator: 'gte', value: 65 },
    ],
  },
  sort:   [{ field: 'harvest_score', direction: 'desc' }],
  select: ['symbol', 'price', 'harvest_score', 'dealer_flow_risk'],
});
data.forEach(r => console.log(r.symbol, r.harvest_score));
```

### .NET
```csharp
using FlashAlpha;
using var client = new FlashAlphaClient("YOUR_API_KEY");

var result = await client.ScreenerAsync(new ScreenerRequest
{
    Filters = new ScreenerGroup
    {
        Op = "and",
        Conditions = new List<object>
        {
            new ScreenerLeaf { Field = "regime",        Operator = "eq",  Value = "positive_gamma" },
            new ScreenerLeaf { Field = "harvest_score", Operator = "gte", Value = 65 },
        },
    },
    Sort   = new List<ScreenerSort> { new() { Field = "harvest_score", Direction = "desc" } },
    Select = new List<string> { "symbol", "price", "harvest_score", "dealer_flow_risk" },
});
```

### Java
```java
import com.flashalpha.FlashAlphaClient;
import java.util.*;

FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");

Map<String, Object> body = new LinkedHashMap<>();
body.put("filters", Map.of(
    "op", "and",
    "conditions", List.of(
        Map.of("field", "regime",        "operator", "eq",  "value", "positive_gamma"),
        Map.of("field", "harvest_score", "operator", "gte", "value", 65)
    )))
body.put("sort",   List.of(Map.of("field", "harvest_score", "direction", "desc")))
body.put("select", List.of("symbol", "price", "harvest_score", "dealer_flow_risk"));

var result = client.screener(body);
```

### Go
```go
import (
    "context"
    flashalpha "github.com/FlashAlpha-lab/flashalpha-go"
)

client := flashalpha.NewClient("YOUR_API_KEY")
ctx := context.Background()

result, _ := client.Screener(ctx, flashalpha.ScreenerRequest{
    Filters: flashalpha.ScreenerGroup{
        Op: "and",
        Conditions: []interface{}{
            flashalpha.ScreenerLeaf{Field: "regime",        Operator: "eq",  Value: "positive_gamma"},
            flashalpha.ScreenerLeaf{Field: "harvest_score", Operator: "gte", Value: 65},
        },
    },
    Sort:   []flashalpha.ScreenerSort{{Field: "harvest_score", Direction: "desc"}},
    Select: []string{"symbol", "price", "harvest_score", "dealer_flow_risk"},
})
```
```

--------------------------------

### Install FlashAlpha .NET SDK

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Instructions on how to add the FlashAlpha SDK package to your .NET project.

```APIDOC
## Install

Use the following command to add the FlashAlpha package to your project:

```bash
dotnet add package FlashAlpha
```

Alternatively, you can add it directly to your `.csproj` file:

```xml
<PackageReference Include="FlashAlpha" Version="0.3.0" />
```
```

--------------------------------

### Install FlashAlpha JavaScript SDK

Source: https://flashalpha.com/docs/lab-api-sdk-javascript

Install the SDK using npm, yarn, or pnpm. Requires Node.js 18+ for native fetch support. No polyfill is needed for browsers or serverless runtimes.

```bash
npm install flashalpha
# or
yarn add flashalpha
# or
pnpm add flashalpha
```

--------------------------------

### Gex Method Example

Source: https://flashalpha.com/docs/lab-api-sdk-go

Example of calling the Gex method and decoding the response into a custom struct.

```APIDOC
### Decode into your own struct
```go
import "encoding/json"

type GexSummary struct {
    NetGex    float64 `json:"net_gex"`
    GammaFlip float64 `json:"gamma_flip"`
}

raw, err := client.Gex(ctx, "SPY")
if err != nil { log.Fatal(err) }

b, _ := json.Marshal(raw)
var s GexSummary
json.Unmarshal(b, &s)
fmt.Println(s.NetGex, s.GammaFlip)
```
```

--------------------------------

### POST /v1/screener Request Example

Source: https://flashalpha.com/docs/lab-api-screener

This cURL example demonstrates how to query the screener endpoint with filters, sorting, and selected fields. Ensure you replace 'YOUR_API_KEY' with your actual API key.

```curl
curl -X POST "https://lab.flashalpha.com/v1/screener" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": { "field": "regime", "operator": "eq", "value": "negative_gamma" },
    "sort": [{ "field": "atm_iv", "direction": "desc" }],
    "select": ["symbol", "price", "regime", "atm_iv", "net_gex"],
    "limit": 10
  }'
```

--------------------------------

### Pagination Example

Source: https://flashalpha.com/docs/lab-api-screener

Demonstrates how to paginate through results using 'limit' and 'offset'. Note that 'offset' is ignored for the Growth tier.

```APIDOC
## Pagination

### Description
Retrieves a paginated list of results, sorted by price.

### Request Body
```json
{
  "sort":   [{ "field": "price", "direction": "desc" }],
  "select": ["symbol", "price"],
  "limit":  10,
  "offset": 10
}
```

### Response Example
(Response structure depends on the `select` fields)
```

--------------------------------

### ScreenerRaw Method Example

Source: https://flashalpha.com/docs/lab-api-sdk-go

Example of using the ScreenerRaw method to get a raw screener payload.

```APIDOC
### Raw screener payload
```go
// ScreenerRaw accepts any value that round-trips through encoding/json
out, err := client.ScreenerRaw(ctx, map[string]interface{}{
    "filters": map[string]interface{}{
        "field":    "atm_iv",
        "operator": "gte",
        "value":    25,
    },
    "sort":   []map[string]string{{"field": "atm_iv", "direction": "desc"}},
    "select": []string{"symbol", "atm_iv"},
    "limit":  20,
})
_ = out
```
```

--------------------------------

### Quick Start

Source: https://flashalpha.com/docs/lab-api-sdk-python

A brief introduction to using the FlashAlpha Python SDK, demonstrating how to initialize the client and make basic API calls for GEX, exposure levels, BSM greeks, and account information.

```APIDOC
## Quick start

```python
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Gamma exposure for SPY
gex = fa.gex("SPY")
print(gex["net_gex"], gex["gamma_flip"])

# Key support / resistance levels
key = fa.exposure_levels("SPY")["levels"]
print(key["call_wall"], key["put_wall"])

# BSM greeks for a single contract
g = fa.greeks(spot=655, strike=660, dte=7, sigma=0.18, type="call")
print(g["delta"], g["gamma"], g["theta"])

# Plan & quota usage
print(fa.account())
```
```

--------------------------------

### Quick Start: Fetching GEX and Exposure Levels

Source: https://flashalpha.com/docs/lab-api-sdk-go

Initialize the client with your API key and make calls to fetch GEX and Exposure Levels. All methods return `map[string]interface{}`. Handle errors appropriately.

```go
package main

import (
    "context"
    "fmt"
    "log"

    flashalpha "github.com/FlashAlpha-lab/flashalpha-go"
)

func main() {
    client := flashalpha.NewClient("YOUR_API_KEY")
    ctx := context.Background()

    // All methods return map[string]interface{}
    gex, err := client.Gex(ctx, "SPY")
    if err != nil { log.Fatal(err) }
    fmt.Println(gex["net_gex"], gex["gamma_flip"])

    // Key support / resistance levels
    lv, err := client.ExposureLevels(ctx, "SPY")
    if err != nil { log.Fatal(err) }
    key := lv["levels"].(map[string]interface{})
    fmt.Println(key["call_wall"], key["put_wall"])

    // BSM greeks (complex params use a struct, not functional options)
    g, err := client.Greeks(ctx, flashalpha.GreeksParams{
        Spot: 655, Strike: 660, Dte: 7, Sigma: 0.18, Type: "call",
    })
    if err != nil { log.Fatal(err) }
    fmt.Println(g["delta"], g["gamma"], g["theta"])
}
```

--------------------------------

### Quick Start with FlashAlpha SDK

Source: https://flashalpha.com/docs/lab-api-sdk-python

Initialize the SDK with your API key and make basic calls for GEX, exposure levels, greeks, and account information.

```python
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Gamma exposure for SPY
gex = fa.gex("SPY")
print(gex["net_gex"], gex["gamma_flip"])

# Key support / resistance levels
key = fa.exposure_levels("SPY")["levels"]
print(key["call_wall"], key["put_wall"])

# BSM greeks for a single contract
g = fa.greeks(spot=655, strike=660, dte=7, sigma=0.18, type="call")
print(g["delta"], g["gamma"], g["theta"])

# Plan & quota usage
print(fa.account())
```

--------------------------------

### Get Full Error Body Example

Source: https://flashalpha.com/docs/lab-api-overview

This example demonstrates how to retrieve the full error body for an API request using cURL. It shows how to include an API key and specifies an invalid endpoint to trigger an error, then pipes the output to `jq` for pretty-printing.

```APIDOC
## GET /v1/exposure/gex/{symbol}

### Description
Retrieves the full error body for a given exposure request. This is useful for debugging and understanding API errors.

### Method
GET

### Endpoint
`/v1/exposure/gex/INVALID`

### Parameters
#### Query Parameters
- **X-Api-Key** (string) - Required - Your API key for authentication.

### Request Example
```bash
curl -s -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/INVALID" | jq .
```

### Response
#### Error Response
- **error** (object) - Contains details about the error.
  - **code** (string) - The error code.
  - **message** (string) - A human-readable error message.

#### Response Example
```json
{
  "error": {
    "code": "INVALID_SYMBOL",
    "message": "The provided symbol is invalid."
  }
}
```
```

--------------------------------

### FlashAlphaClient Initialization and Basic Usage

Source: https://flashalpha.com/docs/lab-api-sdk-java

Demonstrates how to initialize the FlashAlphaClient with an API key and make basic calls to retrieve GEX data and key exposure levels.

```APIDOC
## FlashAlphaClient Initialization and Basic Usage

### Description
Initialize the `FlashAlphaClient` with your API key and use it to fetch Gamma Exposure (GEX) data for a given symbol, as well as key support and resistance levels.

### Method
`FlashAlphaClient` constructor and `gex`, `exposureLevels` methods.

### Usage
```java
import com.flashalpha.FlashAlphaClient;
import com.google.gson.JsonObject;

FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");

// Gamma exposure for SPY
JsonObject gex = client.gex("SPY");
System.out.println(gex.get("net_gex") + " / flip " + gex.get("gamma_flip"));

// Key support / resistance levels
JsonObject key = client.exposureLevels("SPY")
    .getAsJsonObject("levels");
System.out.println("Call wall: " + key.get("call_wall"));
```
```

--------------------------------

### Get Exposure Data with Kotlin Coroutines

Source: https://flashalpha.com/docs/lab-api-sdk-java

Example of fetching exposure data using Kotlin coroutines and the FlashAlphaClient. Ensures IO operations are performed on the appropriate dispatcher.

```kotlin
import com.flashalpha.FlashAlphaClient
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

val fa = FlashAlphaClient("YOUR_API_KEY")

suspend fun getGex(symbol: String) = withContext(Dispatchers.IO) {
    fa.gex(symbol)
}
```

--------------------------------

### Fetch Exposure Levels using JavaScript

Source: https://flashalpha.com/docs/lab-api-levels

Use the fetch API in JavaScript to get exposure levels for a symbol. This example shows how to log the gamma flip and call wall values from the JSON response.

```javascript
const resp = await fetch(
  "https://lab.flashalpha.com/v1/exposure/levels/SPY",
  { headers: { "X-Api-Key": "YOUR_API_KEY" } }
);
const data = await resp.json();
console.log(`Gamma Flip: ${data.levels.gamma_flip}`);
console.log(`Call Wall: ${data.levels.call_wall}`);
```

--------------------------------

### Initialize Client with Default Base URL (Go)

Source: https://flashalpha.com/docs/lab-api-sdk-go

Creates a new Lab API client using the default base URL. Replace 'YOUR_API_KEY' with your actual API key.

```go
// Default base URL
client := flashalpha.NewClient("YOUR_API_KEY")
```

--------------------------------

### Quick Start with FlashAlpha Java SDK

Source: https://flashalpha.com/docs/lab-api-sdk-java

Initialize the FlashAlphaClient with your API key and make calls to retrieve GEX, exposure levels, or BSM greeks. Output is printed to the console.

```java
import com.flashalpha.FlashAlphaClient;
import com.google.gson.JsonObject;

FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");

// Gamma exposure for SPY
JsonObject gex = client.gex("SPY");
System.out.println(gex.get("net_gex") + " / " + gex.get("gamma_flip"));

// Key support / resistance levels
JsonObject key = client.exposureLevels("SPY")
    .getAsJsonObject("levels");
System.out.println("Call wall: " + key.get("call_wall"));

// BSM greeks for a single contract
JsonObject g = client.greeks(655, 660, 7, 0.18, "call", null, null);
System.out.println("delta=" + g.get("delta"));
```

--------------------------------

### Initialize FlashAlphaClient with API Key

Source: https://flashalpha.com/docs/lab-api-sdk-java

Instantiate the FlashAlphaClient with your API key. This is the default configuration.

```java
// Default base URL
FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");
```

--------------------------------

### Client Initialization

Source: https://flashalpha.com/docs/lab-api-sdk-go

Demonstrates how to initialize the FlashAlpha client with default or custom base URLs.

```APIDOC
## Client Configuration

```go
// Default base URL
client := flashalpha.NewClient("YOUR_API_KEY")

// Custom base URL (useful for tests)
client := flashalpha.NewClientWithURL(
    "YOUR_API_KEY",
    "https://lab.flashalpha.com",
)
// Timeout is fixed at 30 seconds.
```
```

--------------------------------

### Error Handling Example

Source: https://flashalpha.com/docs/lab-api-screener

Provides an example of a structured JSON error response, typically returned with a 400 or 403 HTTP status code.

```APIDOC
## Error Handling Example

### Description
Illustrates a typical error response structure for validation or tier restriction errors.

### Response Example
```json
{
  "status": "ERROR",
  "error": "validation_error",
  "message": "Field 'harvest_score' requires the Alpha plan or higher."
}
```
```

--------------------------------

### Ticker Coverage Response Example

Source: https://flashalpha.com/docs/historical-api

This is an example of a successful response for the /v1/tickers endpoint, detailing symbol coverage, date ranges, and data layer counts.

```json
{
  "count": 1,
  "tickers": [
    {
      "symbol": "SPY",
      "coverage": {
        "first": "2018-04-16",
        "last":  "2026-04-02",
        "total_days": 2909,
        "healthy_days": 1972
      },
      "tables": {
        "stocks_days":    2009,
        "options_days":   1972,
        "option_eod_days": 2006,
        "svi_days":        1972
      },
      "gaps": {
        "missing_eod": 3,
        "missing_svi": 36,
        "uncovered_calendar": 3
      },
      "updated_at": "2026-04-14T07:07:36.55353"
    }
  ]
}
```

--------------------------------

### Historical Exposure Summary Response Example

Source: https://flashalpha.com/docs/historical-api

An example response for the historical exposure summary endpoint, showing dealer positioning and interpretations at a specific past moment.

```json
{
  "symbol": "SPY",
  "underlying_price": 246.01,
  "as_of": "2020-03-16T15:30:00",
  "gamma_flip": 270.92,
  "regime": "negative_gamma",
  "exposures": {
    "net_gex":  -2633970601,
    "net_dex": -169419489077,
    "net_vex":  152461756844,
    "net_chex":   -13122349
  },
  "interpretation": {
    "gamma":  "Dealers short gamma - moves amplified, trend following likely",
    "vanna":  "Vol up = dealers buy delta - downside dampened if vol spikes",
    "charm":  "Time decay pushing dealers to sell - pressure into close"
  }
}
```

--------------------------------

### Quick Start with FlashAlpha .NET SDK

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Initialize the FlashAlphaClient with your API key and make calls to retrieve data. All methods return System.Text.Json.JsonElement, which can be navigated using GetProperty() or deserialized into custom types.

```csharp
using FlashAlpha;

using var client = new FlashAlphaClient("YOUR_API_KEY");

// All methods return JsonElement — navigate with GetProperty / indexer
var gex = await client.GexAsync("SPY");
Console.WriteLine($"Net GEX: {gex.GetProperty("net_gex").GetDouble():N0}");
Console.WriteLine($"Flip:    {gex.GetProperty("gamma_flip").GetDouble()}");

// Key support / resistance levels
var key = (await client.ExposureLevelsAsync("SPY")).GetProperty("levels");
Console.WriteLine($"Call wall: {key.GetProperty("call_wall").GetDouble()}");
Console.WriteLine($"Put wall:  {key.GetProperty("put_wall").GetDouble()}");

// BSM greeks for a single contract
var g = await client.GreeksAsync(
    spot: 655, strike: 660, dte: 7, sigma: 0.18, type: "call");
Console.WriteLine($"delta={g.GetProperty("delta").GetDouble()}");
```

--------------------------------

### DEX API Response Example

Source: https://flashalpha.com/docs/lab-api-dex

This is an example of the JSON response structure you can expect from the DEX API. It includes the underlying symbol, price, timestamp, aggregate net DEX, and a breakdown by strike.

```json
{
  "symbol": "SPY",
  "underlying_price": 597.505,
  "as_of": "2026-02-28T16:30:45Z",
  "net_dex": -450000000,
  "strikes": [
    {
      "strike": 575.0,
      "call_dex": 5600000,
      "put_dex": 4200000,
      "net_dex": 9800000
    }
  ]
}
```

--------------------------------

### Stock Quote API Response Example

Source: https://flashalpha.com/docs/lab-api-stock-quote

This is an example of a successful '200 OK' response from the Stock Quote API, detailing the ticker, bid, ask, midpoint, last price, and last update time.

```json
{
  "ticker": "SPY",
  "bid": 597.50,
  "ask": 597.51,
  "mid": 597.505,
  "lastPrice": 597.505,
  "lastUpdate": "2026-02-28T16:30:45Z"
}
```

--------------------------------

### Configure FlashAlphaClient

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Instantiate FlashAlphaClient with an API key and optional base URL and timeout. Alternatively, provide a pre-configured HttpClient.

```csharp
// Simple
using var client = new FlashAlphaClient(
    apiKey: "...",
    baseUrl: "https://lab.flashalpha.com",   // default
    timeout: 30                               // seconds
);

// Or inject a pre-configured HttpClient
using var client2 = new FlashAlphaClient(httpClient);
```

--------------------------------

### TypeScript: Typed Screener Row Example

Source: https://flashalpha.com/docs/lab-api-sdk-javascript

Define custom TypeScript types for screener response data to ensure type safety and enable IDE autocompletion. This example shows how to type the response for symbol, price, net_gex, and regime.

```typescript
type Row = { symbol: string; price: number; net_gex: number; regime: string };
type ScreenerResp = { meta: { returned_count: number }; data: Row[] };

const res = (await fa.screener({
  sort:   [{ field: 'net_gex', direction: 'desc' }],
  select: ['symbol', 'price', 'net_gex', 'regime'],
  limit:  10,
})) as ScreenerResp;

res.data.forEach(r => console.log(r.symbol, r.net_gex));
```

--------------------------------

### Client Configuration

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Explains how to configure and instantiate the `FlashAlphaClient`, including options for API key, base URL, timeout, and injecting a pre-configured `HttpClient`.

```APIDOC
## Client Configuration

### Description
Provides instructions on how to initialize and configure the `FlashAlphaClient`, covering simple instantiation with an API key and advanced configuration using a pre-configured `HttpClient`.

### Simple Configuration
```csharp
// Simple
using var client = new FlashAlphaClient(
    apiKey: "...",
    baseUrl: "https://lab.flashalpha.com",   // default
    timeout: 30                               // seconds
);
```

### Injecting HttpClient
```csharp
// Or inject a pre-configured HttpClient
using var client2 = new FlashAlphaClient(httpClient);
```
```

--------------------------------

### Java Screener Example

Source: https://flashalpha.com/docs/lab-api-screener

Construct a map for the request body and use the `screener` method from the `FlashAlphaClient`. Ensure the `flashalpha` dependency is included.

```java
import com.flashalpha.FlashAlphaClient;
import java.util.*;

FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");

Map<String, Object> body = new LinkedHashMap<>();
body.put("filters", Map.of(
    "op", "and",
    "conditions", List.of(
        Map.of("field", "regime",        "operator", "eq",  "value", "positive_gamma"),
        Map.of("field", "harvest_score", "operator", "gte", "value", 65)
    )))
body.put("sort",   List.of(Map.of("field", "harvest_score", "direction", "desc")))
body.put("select", List.of("symbol", "price", "harvest_score", "dealer_flow_risk"));

var result = client.screener(body);
```

--------------------------------

### GET /v1/symbols

Source: https://flashalpha.com/docs/lab-api-overview

Retrieves a list of symbols that are tracked by the API.

```APIDOC
## GET /v1/symbols

### Description
Tracked symbols

### Method
GET

### Endpoint
`/v1/symbols`
```

--------------------------------

### Initialize Client with Custom Base URL (Go)

Source: https://flashalpha.com/docs/lab-api-sdk-go

Creates a new Lab API client with a custom base URL, useful for testing or specific environments. The timeout is fixed at 30 seconds.

```go
// Custom base URL (useful for tests)
client := flashalpha.NewClientWithURL(
    "YOUR_API_KEY",
    "https://lab.flashalpha.com",
)
// Timeout is fixed at 30 seconds.
```

--------------------------------

### GET /v1/tickers

Source: https://flashalpha.com/docs/lab-api-overview

Retrieves a list of available tickers supported by the API.

```APIDOC
## GET /v1/tickers

### Description
Available tickers

### Method
GET

### Endpoint
`/v1/tickers`
```

--------------------------------

### Unknown Field Error Example

Source: https://flashalpha.com/docs/lab-api-screener

Illustrates a 'validation_error' response when an unknown field is queried.

```json
{ "error": "validation_error", "message": "Unknown field 'atm'" }
```

--------------------------------

### Client Configuration

Source: https://flashalpha.com/docs/lab-api-sdk-java

Demonstrates how to configure the FlashAlphaClient, including setting the API key and optionally overriding the base URL.

```APIDOC
## Client Configuration

### Description
Configure the FlashAlphaClient with your API key. You can also override the default base URL, which is useful for testing with mock servers.

### Initialization
```java
// Default base URL
FlashAlphaClient client = new FlashAlphaClient("YOUR_API_KEY");

// Override base URL (useful for MockWebServer in tests)
FlashAlphaClient client = new FlashAlphaClient(
    "YOUR_API_KEY",
    "https://lab.flashalpha.com"
);

// Timeout is fixed at 30 seconds.
```
```

--------------------------------

### Gex Method with Expiration

Source: https://flashalpha.com/docs/lab-api-sdk-go

Example of calling the Gex method with an expiration date option.

```APIDOC
### Request with deadline
```go
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

 gex, err := client.Gex(ctx, "SPY", flashalpha.WithExpiration("2026-04-10"))
if err != nil { log.Fatal(err) }
_ = gex
```
```

--------------------------------

### Fetch SPY Exposure Summary

Source: https://flashalpha.com/docs/lab-api-overview

This example demonstrates how to fetch the real-time exposure summary for a given stock symbol (e.g., SPY) using the API. It shows how to retrieve the current gamma regime, net GEX, and gamma flip level.

```APIDOC
## Fetch SPY Exposure Summary

### Description
Retrieves the real-time exposure summary for a specified stock symbol, including regime, net GEX, and gamma flip.

### Method
GET

### Endpoint
/v1/exposure/summary/{symbol}

### Parameters
#### Path Parameters
- **symbol** (string) - Required - The stock symbol for which to retrieve the exposure summary (e.g., SPY).

#### Request Headers
- **X-Api-Key** (string) - Required - Your unique API key for authentication.

### Response
#### Success Response (200)
- **regime** (string) - The current gamma regime.
- **exposures** (object) - Contains exposure metrics.
  - **net_gex** (number) - The net gamma exposure value.
- **gamma_flip** (number) - The gamma flip level.

### Request Example
```bash
curl -H "X-Api-Key: YOUR_API_KEY" \
  https://lab.flashalpha.com/v1/exposure/summary/SPY
```

### Response Example
```json
{
  "regime": "bullish",
  "exposures": {
    "net_gex": 1500000000.00
  },
  "gamma_flip": 450.00
}
```
```

--------------------------------

### GET /health

Source: https://flashalpha.com/docs/lab-api-overview

Performs a health check on the API. This endpoint is public and does not require authentication.

```APIDOC
## GET /health

### Description
Health check (public, no auth)

### Method
GET

### Endpoint
`/health`
```

--------------------------------

### GET /v1/account

Source: https://flashalpha.com/docs/lab-api-overview

Retrieves account information, including current usage and plan details.

```APIDOC
## GET /v1/account

### Description
Account info

### Method
GET

### Endpoint
`/v1/account`
```

--------------------------------

### Install FlashAlpha .NET SDK

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Add the FlashAlpha package to your .NET project using the dotnet CLI or by directly editing your .csproj file. This SDK targets .NET 8.0 and newer.

```bash
dotnet add package FlashAlpha
```

```xml
<PackageReference Include="FlashAlpha" Version="0.3.0" />
```

--------------------------------

### GET /stockquote/{ticker}

Source: https://flashalpha.com/docs/lab-api-overview

Retrieves the live stock quote for a given ticker symbol.

```APIDOC
## GET /stockquote/{ticker}

### Description
Live stock quote

### Method
GET

### Endpoint
`/stockquote/{ticker}`

### Parameters
#### Path Parameters
- **ticker** (string) - Required - The stock ticker symbol (e.g., AAPL, MSFT).
```

--------------------------------

### ASP.NET Core & DI Integration

Source: https://flashalpha.com/docs/lab-api-sdk-dotnet

Shows how to configure the FlashAlphaClient using dependency injection in an ASP.NET Core application and consume it in a service.

```APIDOC
## ASP.NET Core & DI

### Description
Integrates the `FlashAlphaClient` into an ASP.NET Core application using the built-in dependency injection container.

### Configuration in `Program.cs`
```csharp
// Program.cs
builder.Services.AddHttpClient<FlashAlphaClient>((sp, http) =>
{
    http.BaseAddress = new Uri("https://lab.flashalpha.com");
    http.DefaultRequestHeaders.Add("X-Api-Key",
        builder.Configuration["FlashAlpha:ApiKey"]);
});
```

### Consuming in a Service
```csharp
// Consume via constructor injection
public class ExposureService(FlashAlphaClient client)
{
    public Task<JsonElement> GetSpyAsync(CancellationToken ct) =>
        client.GexAsync("SPY", ct: ct);
}
```
```

--------------------------------

### GET /v1/maxpain/{symbol}

Source: https://flashalpha.com/docs/historical-api

Retrieves Max Pain and pin probability for a given symbol.

```APIDOC
## GET /v1/maxpain/{symbol}

### Description
Retrieves Max Pain and pin probability for a given symbol.

### Method
GET

### Endpoint
`/v1/maxpain/{symbol}`

### Parameters
#### Path Parameters
- **symbol** (string) - Required - The underlying symbol (e.g., SPY).

#### Query Parameters
- **at** (string) - Optional - The specific timestamp (ISO 8601 format) to retrieve data for. If not provided, the latest available data is returned.

### Request Example
```bash
curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://historical.flashalpha.com/v1/maxpain/SPY?at=2020-03-16T15:30:00"
```

### Response
#### Success Response (200)
- **symbol** (string) - The ticker symbol.
- **as_of** (string) - The timestamp of the data (ISO 8601 format).
- **max_pain** (float) - The strike price at which options expire with the maximum loss for buyers.
- **pin_probability** (float) - The probability of the underlying price pinning at the max pain strike.
```

--------------------------------

### .NET Screener Example

Source: https://flashalpha.com/docs/lab-api-screener

Call the `ScreenerAsync` method using the FlashAlpha .NET client. Add the package with `dotnet add package FlashAlpha`.

```csharp
using FlashAlpha;
using var client = new FlashAlphaClient("YOUR_API_KEY");

var result = await client.ScreenerAsync(new ScreenerRequest
{
    Filters = new ScreenerGroup
    {
        Op = "and",
        Conditions = new List<object>
        {
            new ScreenerLeaf { Field = "regime",        Operator = "eq",  Value = "positive_gamma" },
            new ScreenerLeaf { Field = "harvest_score", Operator = "gte", Value = 65 },
        },
    },
    Sort   = new List<ScreenerSort> { new() { Field = "harvest_score", Direction = "desc" } },
    Select = new List<string> { "symbol", "price", "harvest_score", "dealer_flow_risk" },
});
```

--------------------------------

### Get Exposure Summary Tool

Source: https://flashalpha.com/docs/mcp

Obtain aggregated exposure metrics including net GEX/DEX/VEX/CHEX, market regime, dealer hedging estimates for spot scenarios, and 0DTE breakout. This tool requires a Growth plan.

```python
`get_exposure_summary`
```

--------------------------------

### fa_get Function (Shell)

Source: https://flashalpha.com/docs/lab-api-overview

A shell script function to make GET requests to the FlashAlpha API.

```APIDOC
## fa_get Function (Shell)

### Description
A reusable shell function to make GET requests to the FlashAlpha API. It automatically includes the API key in the request headers and constructs the URL.

### Usage
```bash
# 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"
}

# Example usage:
fa_get /v1/exposure/summary/SPY | jq .
fa_get /stockquote/SPY | jq .
```

### Parameters
- **$1** (string) - Required - The API endpoint path (e.g., \"/v1/exposure/summary/SPY\").
```
Tokens:
Raw