# pip install websockets
import asyncio, json, os
import websockets

API_KEY = os.environ["FERMI_API_KEY"]
URL = f"wss://tickstream.fermi.trade/ticks?api_key={API_KEY}"

async def stream():
    while True:
        try:
            async with websockets.connect(URL) as ws:
                print("Connected")
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "ticks":
                        for tick in msg["data"]:
                            process_tick(tick)
                    elif msg["type"] == "lag":
                        print(f"Warning: dropped {msg['dropped']} ticks")
                    elif msg["type"] == "status":
                        print(f"Upstream: {msg['upstream']}")
        except (websockets.ConnectionClosed, OSError) as e:
            print(f"Disconnected: {e}. Reconnecting in 3s...")
            await asyncio.sleep(3)

def process_tick(tick):
    # tick["tick_number"], tick["transactions"], etc.
    pass

asyncio.run(stream())

// go get github.com/gorilla/websocket
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"
    "github.com/gorilla/websocket"
)

type Message struct {
    Type    string          `json:"type"`
    Count   int             `json:"count"`
    Data    json.RawMessage `json:"data"`
    Dropped int             `json:"dropped"`
}

func main() {
    url := fmt.Sprintf("wss://tickstream.fermi.trade/ticks?api_key=%s",
        os.Getenv("FERMI_API_KEY"))

    for {
        c, _, err := websocket.DefaultDialer.Dial(url, nil)
        if err != nil {
            log.Printf("Connect failed: %v. Retrying in 3s...", err)
            time.Sleep(3 * time.Second)
            continue
        }
        log.Println("Connected")
        for {
            _, raw, err := c.ReadMessage()
            if err != nil {
                log.Printf("Read error: %v. Reconnecting...", err)
                break
            }
            var msg Message
            json.Unmarshal(raw, &msg)
            switch msg.Type {
            case "ticks":
                // Process msg.Data ([]Tick as JSON)
                fmt.Printf("Received %d ticks\n", msg.Count)
            case "lag":
                log.Printf("Dropped %d ticks", msg.Dropped)
            }
        }
        c.Close()
        time.Sleep(3 * time.Second)
    }
}

// Browser — no dependencies needed
const API_KEY = "your-api-key-here";

function connect() {
  const ws = new WebSocket(
    `wss://tickstream.fermi.trade/ticks?api_key=${API_KEY}`
  );

  ws.onmessage = (e) => {
    const msg = JSON.parse(e.data);
    if (msg.type === "ticks") {
      msg.data.forEach(tick => {
        console.log(
          `Tick #${tick.tick_number} | ` +
          `${tick.transactions.length} txns`
        );
      });
    }
  };

  ws.onclose = () => setTimeout(connect, 3000);
  ws.onerror = (e) => console.error("WS error", e);
}

connect();

# pip install grpcio grpcio-tools
# python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. sequencer.proto
import grpc, os, time
from sequencer_pb2 import StreamTicksRequest
from sequencer_pb2_grpc import SequencerServiceStub

def stream():
    api_key = os.environ["FERMI_API_KEY"]
    creds = grpc.ssl_channel_credentials()

    while True:
        try:
            channel = grpc.secure_channel("tickstream.fermi.trade:443", creds)
            stub = SequencerServiceStub(channel)
            metadata = [("x-api-key", api_key)]

            for tick in stub.StreamTicks(StreamTicksRequest(), metadata=metadata):
                process_tick(tick)

            print("Stream ended. Reconnecting...")
        except grpc.RpcError as e:
            print(f"gRPC error: {e.code()} {e.details()}. Retrying...")
        time.sleep(3)

def process_tick(tick):
    print(f"Tick #{tick.tick_number} — {len(tick.transactions)} txns")

stream()

// protoc --go_out=. --go-grpc_out=. sequencer.proto
package main

import (
    "context"
    "crypto/tls"
    "io"
    "log"
    "os"
    "time"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
    pb "your/module/sequencer"
)

func main() {
    creds := credentials.NewTLS(&tls.Config{})
    conn, err := grpc.Dial("tickstream.fermi.trade:443",
        grpc.WithTransportCredentials(creds))
    if err != nil { log.Fatal(err) }
    defer conn.Close()

    client := pb.NewSequencerServiceClient(conn)

    for {
        ctx := metadata.AppendToOutgoingContext(
            context.Background(),
            "x-api-key", os.Getenv("FERMI_API_KEY"))

        stream, err := client.StreamTicks(ctx,
            &pb.StreamTicksRequest{StartTick: 0})
        if err != nil {
            log.Printf("Connect: %v. Retrying...", err)
            time.Sleep(3 * time.Second)
            continue
        }

        for {
            tick, err := stream.Recv()
            if err == io.EOF { break }
            if err != nil {
                log.Printf("Stream: %v", err)
                break
            }
            processTick(tick)
        }
        time.Sleep(3 * time.Second)
    }
}

// npm install @grpc/grpc-js @grpc/proto-loader
const grpc = require("@grpc/grpc-js");
const protoLoader = require("@grpc/proto-loader");

const pkgDef = protoLoader.loadSync("sequencer.proto");
const proto = grpc.loadPackageDefinition(pkgDef)
    .continuum.sequencer.v1;

function connect() {
  const client = new proto.SequencerService(
    "tickstream.fermi.trade:443",
    grpc.credentials.createSsl()
  );

  const meta = new grpc.Metadata();
  meta.add("x-api-key", process.env.FERMI_API_KEY);

  const stream = client.StreamTicks(
    { start_tick: 0 }, meta
  );

  stream.on("data", (tick) => {
    console.log(
      `Tick #${tick.tick_number} — ` +
      `${tick.transactions.length} txns`
    );
  });

  stream.on("error", (err) => {
    console.error(`gRPC error: ${err.message}. Retrying...`);
    setTimeout(connect, 3000);
  });

  stream.on("end", () => {
    console.log("Stream ended. Reconnecting...");
    setTimeout(connect, 3000);
  });
}

connect();