Get started

Quickstart

In five minutes: create a key, open a connection, subscribe to large aggressive orders on the E-mini Nasdaq-100 future (NQ), then ask for the same thing over a past period.

1. Create an API key

Sign in with your email address: you get a sign-in link, no password needed, and your account is created the first time you sign in. Then create a key in your account. Copy it right away: it is shown only once.

A key (fc_live_…) has the rights of your plans. Without a plan, it is free, with data delayed by 10 minutes and the last 7 days of history: enough to build your integration. With the Live plan, the same key receives real-time data and the last 7 days of history, without consuming any compute budget.

Store the key in an environment variable on your server. In a macOS or Linux terminal (bash, zsh):

BASH
export FATHOM_CHARTS_API_KEY="fc_live_…"

On Windows, in PowerShell:

POWERSHELL
$env:FATHOM_CHARTS_API_KEY = "fc_live_…"

Or in the Command Prompt (cmd), without quotes:

CMD
set FATHOM_CHARTS_API_KEY=fc_live_…

The variable only lasts for that terminal: run the commands on this page in the same one. If the connection is closed with code 4001, or if the SDK throws a CONFIGURATION error, see Troubleshooting.

Never put the key in code that runs in a browser. For a web page, see Browser access.

2. Open a connection

For a first try, the wscat command-line tool is all you need (-y skips the install prompt of npx):

BASH
npx -y wscat -c wss://stream.fathomcharts.com/v1 -H "Authorization: Bearer $FATHOM_CHARTS_API_KEY"

In PowerShell:

POWERSHELL
npx -y wscat -c wss://stream.fathomcharts.com/v1 -H "Authorization: Bearer $env:FATHOM_CHARTS_API_KEY"

In cmd:

CMD
npx -y wscat -c wss://stream.fathomcharts.com/v1 -H "Authorization: Bearer %FATHOM_CHARTS_API_KEY%"

3. Subscribe

Once connected, send this message. It asks for large aggressive orders of at least 30 contracts (Fathom Trades) on the front-month NQ contract (NQ.front):

JSON
{"t":"subscribe","sub":"bt","instrument":"NQ.front","indicator":"big-trades","params":{"minimum":30},"mode":"confirmed","from":"live"}
  • sub is a name you choose for this subscription. Every message about it carries that name, so you can open several subscriptions on the same connection;
  • mode: "confirmed" sends only completed orders. With mode: "live", you also get the order in progress, updated on every trade;
  • params sets minimum explicitly. A parameter you leave out takes the current default value of the ticker, which we update over time; explicit values keep the results identical over time. The current NQ default of minimum is on the Fathom Trades page. When it is not 30, this subscription uses a custom configuration: a combination of parameters that differs from the defaults of its ticker. Each plan allows a set number of them at a time (one with the Sandbox), released when the subscription closes. To use the defaults instead, leave out params.

Outside an interactive terminal (a script, CI, a coding agent), you cannot type the message. In bash, -x sends it as soon as the connection opens. wscat closes the connection as soon as its standard input closes, so keep it open with sleep: here, wscat prints what arrives for 30 seconds.

BASH
sleep 30 | npx -y wscat -c wss://stream.fathomcharts.com/v1 -H "Authorization: Bearer $FATHOM_CHARTS_API_KEY" -x '{"t":"subscribe","sub":"bt","instrument":"NQ.front","indicator":"big-trades","params":{"minimum":30},"mode":"confirmed","from":"live"}'

PowerShell and cmd do not pass the quotes of this JSON to wscat intact. There, use this Node script instead. It sends the same message and prints every message received. In an empty folder, run npm install ws, save the script as stream.mjs, then run node stream.mjs (Ctrl+C to stop).

JS
import WebSocket from 'ws';

const ws = new WebSocket('wss://stream.fathomcharts.com/v1', {
  headers: { Authorization: `Bearer ${process.env.FATHOM_CHARTS_API_KEY}` },
});
ws.on('open', () => ws.send(JSON.stringify({
  t: 'subscribe', sub: 'bt', instrument: 'NQ.front', indicator: 'big-trades',
  params: { minimum: 30 }, mode: 'confirmed', from: 'live',
})));
ws.on('message', (data) => console.log(String(data)));
ws.on('close', (code, reason) => console.log('closed', code, String(reason)));

4. Read the messages

Here is what this subscription received at the US cash open (09:30 New York time) on September 24, 2026, with the Live plan (the snapshot is shortened):

TEXT
{"t":"hb","cursors":{}}
{"sub":"bt","t":"subscribed","topic":"368bf15c2d34a77407c10b4f46b79e04","instrument":"NQZ6","tickSizeNanos":"250000000","engine":"82cbdecf93748dd5"}
{"sub":"bt","t":"snapshot","cursor":"20720.110992.0","items":[…]}
{"sub":"bt","t":"status","state":"live","lagMs":0}
{"sub":"bt","cursor":"20720.111434.0","t":"upsert","id":"1790256600533489285:0","final":true,"ts":"1790256600535054015","data":{"side":"sell","volume":66,"trades":32,"start":"1790256600533489285","end":"1790256600533489285","first":122041,"last":122017,"price":122017,"vwap":122027.71212121213}}
{"sub":"bt","cursor":"20720.112164.0","t":"upsert","id":"1790256605021635921:0","final":true,"ts":"1790256605033449615","data":{"side":"buy","volume":32,"trades":30,"start":"1790256605021635921","end":"1790256605023486337","first":122101,"last":122114,"price":122114,"vwap":122110.125}}
{"t":"hb","cursors":{"bt":"20720.112164.0"}}

In order:

  1. hb: the heartbeat, sent every 5 seconds to confirm the connection is alive. For each subscription, it gives the position the stream has reached, usually the cursor of the last message sent (see Cursors and resuming). It can arrive before subscribed: the subscription is not in it yet;
  2. subscribed: the subscription is accepted, on the NQZ6 contract that NQ.front designates;
  3. snapshot: the objects that already existed when you subscribed, here the last 32 large orders completed since the session opened (18:00 the day before, New York time). A snapshot holds at most 32 completed objects. Its cursor is the position of the last update published before your subscribe;
  4. status: the stream is live. Just after the engine starts, a first status can say warming: the snapshot then arrives a few seconds later, followed by status live;
  5. upsert: a new object, here a completed large order.

The first upsert describes a sell order of 66 contracts, filled in 32 trades, that pushed the price down from 122041 to 122017 ticks, or from 30,510.25 to 30,504.25 points. To convert ticks to points, see Prices and timestamps; the first stream of the SDKs converts prices and times in one line each. Every field is documented on the indicator page.

Without a plan, you get the same messages 10 minutes late. While the market is closed (weekend, daily break), the status is market_closed and no upsert arrives before it reopens.

Keep the cursor of the last message you received: you will need it to resume after a disconnect.

5. Use the SDK

The SDKs handle authentication, the initial snapshot, resuming after a disconnect and filtering duplicates for you, in TypeScript, Python, C# and Rust. The raw WebSocket client, the token server and the browser pages, Chart integration and Trading bot are in TypeScript only. In an empty folder, create the project:

Python 3.11 or later (python3 on macOS and Linux). The second command below is for bash and zsh. On Windows, the environment is in .venv\Scripts, so replace that command:

  • in PowerShell, with .venv\Scripts\Activate.ps1. If scripts are disabled, allow them once with Set-ExecutionPolicy -Scope CurrentUser RemoteSigned;
  • in cmd, with .venv\Scripts\activate;
  • in Git Bash, with source .venv/Scripts/activate.

If the activation fails, stop there: pip install would otherwise install the package for the whole system.

terminal
npm init -y
npm pkg set type=module
npm install @fathom-charts/sdk@0.6.0 ws
mkdir src
terminal
python -m venv .venv
source .venv/bin/activate
pip install fathom-charts==0.6.0
terminal
dotnet new console -o BigTrades
cd BigTrades
dotnet add package FathomCharts --version 0.6.0
terminal
cargo new big-trades
cd big-trades
cargo add fathom-charts@0.6.0
cargo add tokio --features full
cargo add futures serde serde_json --features serde/derive

The package is an ES module only: your project must declare "type": "module" in its package.json. These commands are the same in PowerShell and cmd. In Node, the ws package opens the connection with the Authorization header; browsers use their native WebSocket.

Then generate the types of each indicator’s data from the catalog (GET /v1/indicators, no authentication), next to the program that imports them:

terminal
npx -p @fathom-charts/sdk@0.6.0 fathom-charts-types https://api.fathomcharts.com/v1/indicators src/fathom-charts-types.ts
terminal
fathom-charts-types https://api.fathomcharts.com/v1/indicators fathom_charts_types.py
terminal
dotnet dnx FathomCharts.Types@0.6.0 https://api.fathomcharts.com/v1/indicators FathomChartsTypes.cs
terminal
cargo install fathom-charts@0.6.0 --features cli --locked
fathom-charts-types https://api.fathomcharts.com/v1/indicators src/fathom_charts_types.rs

dotnet dnx comes with the .NET 10 SDK and works in every shell (the short dnx is not found in Git Bash); the first time, it asks before downloading the tool. With an earlier SDK, install the tool once with dotnet tool install -g FathomCharts.Types --version 0.6.0, then run FathomCharts.Types with the same arguments. The file declares the FathomCharts.Indicators namespace, with BigTradesParams, BigTradesData and IndicatorIds used below: without it, the program does not compile.

Then save this program:

src/big-trades.ts
import { FathomChartsStream } from '@fathom-charts/sdk';
import type { BigTradesData } from './fathom-charts-types.js';

const stream = new FathomChartsStream({
  url: 'wss://stream.fathomcharts.com/v1',
  apiKey: process.env.FATHOM_CHARTS_API_KEY!,
  onStateChange: (state) => console.log('connection', state),
});

const bigTrades = stream.subscribe<BigTradesData>({
  instrument: 'NQ.front',
  indicator: 'big-trades',
  params: { minimum: 30 },
  mode: 'confirmed',
});

for await (const event of bigTrades) {
  if (event.type === 'subscribed') console.log('subscribed', event.instrument);
  if (event.type === 'snapshot') console.log('snapshot', event.items.length, 'objects');
  if (event.type === 'status') console.log('status', event.state);
  if (event.type === 'upsert') console.log(event.data.side, event.data.volume, event.data.price);
}
big_trades.py
import asyncio
import os

from fathom_charts import FathomChartsStream, Snapshot, Status, Subscribed, Upsert
from fathom_charts_types import BigTradesData


async def main() -> None:
    async with FathomChartsStream(
        url="wss://stream.fathomcharts.com/v1",
        api_key=os.environ["FATHOM_CHARTS_API_KEY"],
        on_state_change=lambda state: print("connection", state),
    ) as stream:
        async with stream.subscribe(
            instrument="NQ.front",
            indicator="big-trades",
            params={"minimum": 30},
            mode="confirmed",
            data=BigTradesData,
        ) as big_trades:
            async for event in big_trades:
                match event:
                    case Subscribed():
                        print("subscribed", event.instrument)
                    case Snapshot():
                        print("snapshot", len(event.items), "objects")
                    case Status():
                        print("status", event.state)
                    case Upsert():
                        print(event.data["side"], event.data["volume"], event.data["price"])
                    case _:
                        pass


asyncio.run(main())
Program.cs
using FathomCharts;
using FathomCharts.Indicators;

await using var stream = new FathomChartsStream(new StreamOptions
{
    Url = "wss://stream.fathomcharts.com/v1",
    ApiKey = Environment.GetEnvironmentVariable("FATHOM_CHARTS_API_KEY"),
    OnStateChange = state => Console.WriteLine($"connection {state}"),
});

var bigTrades = stream.Subscribe<BigTradesData>(new SubscribeOptions
{
    Instrument = "NQ.front",
    Indicator = IndicatorIds.BigTrades,
    Params = new BigTradesParams { Minimum = 30 },
    Mode = Mode.Confirmed,
});

await foreach (var e in bigTrades)
{
    switch (e)
    {
        case Subscribed subscribed:
            Console.WriteLine($"subscribed {subscribed.Instrument}");
            break;
        case Snapshot<BigTradesData> snapshot:
            Console.WriteLine($"snapshot {snapshot.Items.Count} objects");
            break;
        case Status status:
            Console.WriteLine($"status {status.State}");
            break;
        case Upsert<BigTradesData> upsert:
            Console.WriteLine($"{upsert.Data.Side} {upsert.Data.Volume} {upsert.Data.Price}");
            break;
    }
}
src/main.rs
use fathom_charts::{FathomChartsStream, Mode, StreamEvent, SubscribeOptions};
use futures::StreamExt;
use serde_json::json;

mod fathom_charts_types;
use fathom_charts_types::BigTradesData;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let stream = FathomChartsStream::builder("wss://stream.fathomcharts.com/v1")
        .api_key(std::env::var("FATHOM_CHARTS_API_KEY").map_err(|_| "FATHOM_CHARTS_API_KEY is not set")?)
        .on_state_change(|state| println!("connection {state:?}"))
        .build()?;

    let mut big_trades = stream.subscribe::<BigTradesData>(
        SubscribeOptions::new("NQ.front", "big-trades")
            .params(json!({ "minimum": 30 }))
            .mode(Mode::Confirmed),
    )?;

    while let Some(event) = big_trades.next().await {
        match event? {
            StreamEvent::Subscribed(subscribed) => println!("subscribed {}", subscribed.instrument),
            StreamEvent::Snapshot(snapshot) => println!("snapshot {} objects", snapshot.items.len()),
            StreamEvent::Status(status) => println!("status {}", status.state),
            StreamEvent::Upsert(upsert) => println!("{} {} {}", upsert.data.side, upsert.data.volume, upsert.data.price),
            _ => {}
        }
    }
    Ok(())
}

And run it, in the terminal where the key is set:

terminal
npx -y tsx src/big-trades.ts
terminal
python big_trades.py
terminal
dotnet run
terminal
cargo run

When the output goes to a pipe or a file (a CI job, a coding agent, | tee), Python buffers it, and the program seems to print nothing for a long time. Run it with python -u big_trades.py, or set the PYTHONUNBUFFERED=1 environment variable, to print each line at once.

The program runs until you stop it with Ctrl+C (Python then prints a KeyboardInterrupt traceback: wrap asyncio.run(main()) in try/except KeyboardInterrupt to stop quietly). Several minutes can go by without a large order, especially outside US cash hours. The connection open (connection Open in C# and Rust), subscribed and status lines printed at the start already confirm that the stream works. If they do not appear, see Troubleshooting.

tsx runs the program without checking types. To check them (in your editor, or with npx tsc), also run npm install -D typescript @types/node and add this tsconfig.json at the root of the folder:

JSON
{ "compilerOptions": { "module": "nodenext", "target": "es2022", "types": ["node"], "strict": true, "noEmit": true } }

The SDK hands you the subscription’s messages as events named after the message: subscribed, snapshot, upsert, remove, status, reset and notice. hb and pong are handled by the SDK and not handed to you; an error ends the loop with the SDK’s error. You tell stream events apart by their kind (event.type in TypeScript, the event class in Python and C#, the StreamEvent variant in Rust), while history items keep the protocol’s t field, upsert or remove (m.t, m["t"] in Python, m.Type in C#, see step 6). The events, the connection lifecycle and every SDK’s reference: SDKs.

6. Run the same request over history

The same instrument, indicator and params work over a past period. Times are timestamps in nanoseconds since January 1, 1970 UTC, sent as strings. Here, the last 5 completed days: REST history stops at midnight UTC (the current day is not in it yet), 5 days hold at least two complete sessions outside long holiday closures, and the range stays within the Sandbox’s 7 days. It therefore works without a plan or with the Historical plan (with the Live plan alone, history is rejected with 403 FORBIDDEN). "mode": "confirmed" keeps only completed orders.

from and to select updates by the time our servers received them, not objects: the final version of an object completed after to is not in the result, and in confirmed mode that object is missing entirely. The last bar of a session, for example, is only published by the first trade of the 18:00 New York reopen (see History).

This request costs 1 compute unit per trade of the 5 days, about half a million to a few million compute units on NQ, out of the Sandbox’s 50 million a month. Estimate it first, for free, by sending the same body to /v1/indicator-queries/estimate (see Estimate the cost):

BASH
TODAY=$(( $(date +%s) / 86400 * 86400 ))
FROM="$((TODAY - 5 * 86400))000000000"
TO="${TODAY}000000000"

curl https://api.fathomcharts.com/v1/indicator-queries/estimate \
  -H "Authorization: Bearer $FATHOM_CHARTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"instrument\":\"NQ.front\",\"indicator\":\"big-trades\",\"params\":{\"minimum\":30},\"mode\":\"confirmed\",\"from\":\"$FROM\",\"to\":\"$TO\"}"

Then run it:

BASH
curl https://api.fathomcharts.com/v1/indicator-queries \
  -H "Authorization: Bearer $FATHOM_CHARTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"instrument\":\"NQ.front\",\"indicator\":\"big-trades\",\"params\":{\"minimum\":30},\"mode\":\"confirmed\",\"from\":\"$FROM\",\"to\":\"$TO\"}"

In PowerShell, write curl.exe: in Windows PowerShell 5.1, curl alone is another command. The body goes through a file, because PowerShell 5.1 strips the quotes of a JSON argument passed to a program:

POWERSHELL
$today = [long][Math]::Floor([DateTimeOffset]::UtcNow.ToUnixTimeSeconds() / 86400) * 86400
$body = @{
  instrument = "NQ.front"; indicator = "big-trades"; params = @{ minimum = 30 }; mode = "confirmed"
  from = "$($today - 5 * 86400)000000000"; to = "$($today)000000000"
} | ConvertTo-Json -Compress
Set-Content -Path query.json -Value $body -Encoding ascii

curl.exe https://api.fathomcharts.com/v1/indicator-queries/estimate -H "Authorization: Bearer $env:FATHOM_CHARTS_API_KEY" -H "Content-Type: application/json" -d "@query.json"
curl.exe https://api.fathomcharts.com/v1/indicator-queries -H "Authorization: Bearer $env:FATHOM_CHARTS_API_KEY" -H "Content-Type: application/json" -d "@query.json"

You get a page of results (items), its cost in compute units (computeUnits, charged against your monthly compute budget) and a next field. A page holds at most 1,000 results by default: as long as next is not null, send the same request with "cursor": "<next value>" to get the next page. With the SDK, rest.pages()rest.pages()rest.PagesAsync()rest.pages() follows next for you. Save this program as a second file in TypeScript and Python, or in place of the first one in C# (a C# project has one entry point). In Rust, save it as a second program, src/bin/history.rs (its #[path] line reaches the types file in src/). Run it the same way (npx -y tsx src/history.ts, python history.py, dotnet run, cargo run --bin history). In Rust, the project now has two programs, so cargo run alone no longer knows which one to run: start the stream again with cargo run --bin big-trades.

src/history.ts
import { FathomChartsRest } from '@fathom-charts/sdk';
import type { BigTradesData } from './fathom-charts-types.js';

const rest = new FathomChartsRest({ baseUrl: 'https://api.fathomcharts.com', apiKey: process.env.FATHOM_CHARTS_API_KEY! });

// The last 5 completed UTC days, in nanoseconds.
const today = Math.floor(Date.now() / 86_400_000) * 86_400;
let computeUnits = 0;
for await (const page of rest.pages<BigTradesData>({
  instrument: 'NQ.front',
  indicator: 'big-trades',
  params: { minimum: 30 },
  mode: 'confirmed',
  from: `${today - 5 * 86_400}000000000`,
  to: `${today}000000000`,
})) {
  for (const m of page.items) {
    if (m.t === 'upsert' && m.data) console.log(m.cursor, m.data.side, m.data.volume, m.data.price);
  }
  computeUnits += page.computeUnits;
}
console.log('compute units:', computeUnits);
history.py
import asyncio
import os
import time

from fathom_charts import FathomChartsRest, Page
from fathom_charts_types import BigTradesData


async def main() -> None:
    # The last 5 completed UTC days, in nanoseconds.
    today = int(time.time()) // 86_400 * 86_400
    compute_units = 0
    async with FathomChartsRest(base_url="https://api.fathomcharts.com", api_key=os.environ["FATHOM_CHARTS_API_KEY"]) as rest:
        page: Page[BigTradesData]
        async for page in rest.pages({
            "instrument": "NQ.front",
            "indicator": "big-trades",
            "params": {"minimum": 30},
            "mode": "confirmed",
            "from": f"{today - 5 * 86_400}000000000",
            "to": f"{today}000000000",
        }):
            for m in page["items"]:
                if m["t"] == "upsert" and "data" in m:
                    print(m["cursor"], m["data"]["side"], m["data"]["volume"], m["data"]["price"])
            compute_units += page["computeUnits"]
    print("compute units:", compute_units)


asyncio.run(main())
Program.cs
using FathomCharts;
using FathomCharts.Indicators;

using var rest = new FathomChartsRest(new RestOptions
{
    BaseUrl = "https://api.fathomcharts.com",
    ApiKey = Environment.GetEnvironmentVariable("FATHOM_CHARTS_API_KEY"),
});

// The last 5 completed UTC days, in nanoseconds.
var today = DateTimeOffset.UtcNow.ToUnixTimeSeconds() / 86_400 * 86_400;
long computeUnits = 0;
await foreach (var page in rest.PagesAsync<BigTradesData>(new PageQuery
{
    Instrument = "NQ.front",
    Indicator = IndicatorIds.BigTrades,
    Params = new BigTradesParams { Minimum = 30 },
    Mode = Mode.Confirmed,
    From = $"{today - 5 * 86_400}000000000",
    To = $"{today}000000000",
}))
{
    foreach (var m in page.Items)
    {
        if (m is { Type: MutationType.Upsert, Data: { } data })
            Console.WriteLine($"{m.Cursor} {data.Side} {data.Volume} {data.Price}");
    }
    computeUnits += page.ComputeUnits;
}
Console.WriteLine($"compute units: {computeUnits}");
src/bin/history.rs
use fathom_charts::{FathomChartsRest, Mode, MutationKind, PageQuery};
use futures::StreamExt;
use serde_json::json;

#[path = "../fathom_charts_types.rs"]
mod fathom_charts_types;
use fathom_charts_types::BigTradesData;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rest = FathomChartsRest::new(
        "https://api.fathomcharts.com",
        std::env::var("FATHOM_CHARTS_API_KEY").map_err(|_| "FATHOM_CHARTS_API_KEY is not set")?,
    )?;

    // The last 5 completed UTC days, in nanoseconds.
    let today = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)?.as_secs() / 86_400 * 86_400;
    let query = PageQuery::new("NQ.front", "big-trades", format!("{}000000000", today - 5 * 86_400), format!("{today}000000000"))
        .params(json!({ "minimum": 30 }))
        .mode(Mode::Confirmed);

    let mut compute_units = 0.0;
    let mut pages = Box::pin(rest.pages::<BigTradesData>(query));
    while let Some(page) = pages.next().await {
        let page = page?;
        for m in page.items {
            if let (MutationKind::Upsert, Some(data)) = (m.t, m.data) {
                println!("{} {} {} {}", m.cursor, data.side, data.volume, data.price);
            }
        }
        compute_units += page.compute_units;
    }
    println!("compute units: {compute_units}");
    Ok(())
}

Each update has the same id and the same cursor as when the real-time stream published it. In live mode (the default), history also includes the intermediate versions (final: false) published while each object was being built. rest.history()rest.history()rest.HistoryAsync()rest.history() yields the results one by one, across pages. See History.

Troubleshooting

  • The connection is closed with code 4001. The key did not reach the server. Each shell reads the variable its own way: $FATHOM_CHARTS_API_KEY in bash, $env:FATHOM_CHARTS_API_KEY in PowerShell, %FATHOM_CHARTS_API_KEY% in cmd. A variable written the wrong way sends an empty key, or the variable’s name itself, in the Authorization header.
  • The key works in one terminal, not in another. The variable only lasts for the terminal where you set it: set it again in the new one.
  • cmd: the key is refused although it looks right. In cmd, set keeps everything up to the end of the line, trailing spaces included. Do not leave a space after the key.
  • The SDK throws a CONFIGURATION error when the client is created. The key is empty, or has spaces or control characters around it. A .env file with Windows line endings, for example, leaves a \r at the end.
  • The Python or Rust program stops before connecting. The variable is not set at all in that terminal, and the program fails when it reads it.
  • subscribed arrives, but no snapshot and no status after a few seconds. Check the state of the instrument with GET /v1/status.
  • The connection state goes from open to reconnecting in a loop. Your account has reached its connection limit (4029 TOO_MANY_CONNECTIONS, see Limits). Close the programs you no longer use. The SDK retries for 2 minutes, then fails with TOO_MANY_CONNECTIONS.

Next steps

  • Authentication: restrict a key, rotate it, open the stream from a browser.
  • Real time: keep your state in sync, resume after a disconnect.
  • SDKs: the behavior the SDKs share, and the reference of each one.
  • Indicator catalog: parameters and data for every indicator.
  • Use with an LLM: give this documentation to your AI assistant or coding agent.