Real time

// Aicscan real-time client (Node.js 18+, "ws" package: npm install ws).
import WebSocket from 'ws';

const URL = 'wss://aicscan.io/api/ws/alertes';
const DELAYS = [1, 2, 5, 10, 30]; // seconds between reconnections
let lastId = null; // persist it to resume after a restart
let failures = 0;
let stop = false; // key refused: no point retrying

function connect() {
  const url = lastId == null ? URL : `${URL}?last_id=${lastId}`;
  const ws = new WebSocket(url, {
    headers: { Authorization: `Bearer ${process.env.AICSCAN_API_KEY}` },
  });

  ws.on('message', (data) => {
    const msg = JSON.parse(data.toString());
    if (msg.type === 'hello') {
      failures = 0;
      lastId ??= msg.last_id;
    } else if (msg.type === 'alert') {
      if (lastId != null && msg.id <= lastId) return; // already received
      lastId = msg.id;
      const a = msg.alert;
      console.log(a.severity, a.stage, a.title);
    } else if (msg.type === 'gap') {
      console.warn(`alerts ${msg.from + 1} to ${msg.to} not replayed: see GET /v1/matches`);
    }
  });

  // Refused at opening: 401, 403, 429… with a JSON body.
  ws.on('unexpected-response', (_req, res) => {
    let body = '';
    res.on('data', (c) => (body += c));
    res.on('end', () => console.error('connection refused', res.statusCode, body));
    stop = res.statusCode === 401 || res.statusCode === 403;
  });

  ws.on('close', (code) => {
    if (stop) return;
    if (code === 4401) return console.error('access revoked or expired: not reconnecting');
    const delay = DELAYS[Math.min(failures++, DELAYS.length - 1)];
    setTimeout(connect, delay * 1000);
  });
  ws.on('error', () => {}); // a "close" event always follows
}

connect();

# Aicscan real-time client (Python 3.9+, "websockets" package, version 14 or later).
import asyncio
import json
import os

import websockets

URL = "wss://aicscan.io/api/ws/alertes"
DELAYS = [1, 2, 5, 10, 30]  # seconds between reconnections


async def main():
    last_id = None  # persist it to resume after a restart
    failures = 0
    headers = {"Authorization": f"Bearer {os.environ['AICSCAN_API_KEY']}"}
    while True:
        url = URL if last_id is None else f"{URL}?last_id={last_id}"
        try:
            async with websockets.connect(url, additional_headers=headers) as ws:
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "hello":
                        failures = 0
                        if last_id is None:
                            last_id = msg["last_id"]
                    elif msg["type"] == "alert":
                        if last_id is not None and msg["id"] <= last_id:
                            continue  # already received
                        last_id = msg["id"]
                        alert = msg["alert"]
                        print(alert["severity"], alert["stage"], alert["title"])
                    elif msg["type"] == "gap":
                        print(f"alerts {msg['from'] + 1} to {msg['to']} not replayed: see GET /v1/matches")
        except websockets.InvalidStatus as e:  # refused at opening (401, 403, 429…)
            print("connection refused", e.response.status_code, e.response.body.decode(errors="replace"))
            if e.response.status_code in (401, 403):
                return
        except websockets.ConnectionClosed as e:
            if e.rcvd is not None and e.rcvd.code == 4401:
                print("access revoked or expired: not reconnecting")
                return
        except OSError:
            pass  # network unavailable
        await asyncio.sleep(DELAYS[min(failures, len(DELAYS) - 1)])
        failures += 1


asyncio.run(main())