Pulling your day's events and transcripts

Authorization: Bearer st_1a2b3c4d…

# macOS / Linux (bash or zsh) — replace the values with yours
export ANTARE_TOKEN=st_…
export ANTARE_ORG_ID=1f0c2a8e-7b3d-4e5f-9a6c-2d8e4b7f1a30
export ANTARE_API_HOST=https://api.eu-west-2.console.antare.ai

curl -sS -w '\nHTTP %{http_code}\n' \
  -H "Authorization: Bearer $ANTARE_TOKEN" \
  "$ANTARE_API_HOST/orgs/$ANTARE_ORG_ID/cameras?limit=1"

# Windows (PowerShell) — curl.exe is the real curl, not the PowerShell alias
$env:ANTARE_TOKEN    = "st_…"
$env:ANTARE_ORG_ID   = "1f0c2a8e-7b3d-4e5f-9a6c-2d8e4b7f1a30"
$env:ANTARE_API_HOST = "https://api.eu-west-2.console.antare.ai"

curl.exe -sS -w "`nHTTP %{http_code}`n" `
  -H "Authorization: Bearer $env:ANTARE_TOKEN" `
  "$env:ANTARE_API_HOST/orgs/$env:ANTARE_ORG_ID/cameras?limit=1"

HTTP 200   with {"data":[…],"meta":…} above it  → token, id and host are all right
HTTP 404   {"message":"not found"}               → wrong host for this org (try the other), or wrong id
HTTP 401   {"error":{"status":"unauthenticated"}} → token wrong or expired
HTTP 403   "caller does not have permission…"     → the service's role lacks View devices

{
  "limit":  100,
  "sort":   [{ "startedAt": "desc" }, { "id": "asc" }],
  "filter": {
    "startedAt": { "gt": "2026-09-27T23:59:59Z", "lt": "2026-09-29T00:00:00Z" }
  }
}

{
  "id":           "a1b2c3d4-…",
  "startedAt":    "2026-09-28T12:53:42Z",
  "endedAt":      "2026-09-28T12:55:11Z",
  "severity":     1,
  "incidentType": "neutral",
  "source":       "uploadAnalysis",
  "title":        { "data": [{ "text": "Investigation of strange kitchen odor" }] },
  "summaryShort": { "data": [{ "text": "Multiple staff members investigate a persistent damp smell…" }] },
  "media":        [{ "id": "…", "camera": { "id": "c0ffee01-…" }, "liveCamera": null }],
  "buttonPushes": [{ "cameraId": "…", "buttonId": "…", "pushedAt": "2026-09-28T12:53:40Z" }],
  "labelIds":     [], "categoryIds": []
}

// Extracting camera ids from a day's incidents
const cameraIds = [...new Set(
  incidents.flatMap(i => (i.media || []).map(m =>
    (m.camera && m.camera.id) || (m.liveCamera && m.liveCamera.id)
  )).filter(Boolean)
)];

// Titles are structured, not plain text
const title = incident.title?.data?.[0]?.text ?? "";

const presses = incidents.flatMap(i =>
  (i.buttonPushes || []).map(p => ({ incidentId: i.id, ...p })));

GET …/cameras/c0ffee01-…/transcript
      ?start=2026-09-27T23:55:00Z
      &end=2026-09-29T00:05:00Z

{
  "data": {
    "utterances": [
      {
        "startedAt": "2026-09-28T10:50:52.1Z",
        "endedAt":   "2026-09-28T10:51:01.139Z",
        "speaker":   null,
        "fragment":  "And I guess that's",
        "startMs":   39352100,  // offset from the start you asked for — see below
        "endMs":     39361139
      }
    ]
  }
}

const HOST  = process.env.ANTARE_API_HOST;   // https://api.eu-west-2.console.antare.ai
const ORG   = process.env.ANTARE_ORG_ID;     // your organization's UUID
const TOKEN = process.env.ANTARE_TOKEN;      // st_…, from Manage → Services
const day   = "2026-09-28";                  // a UTC day

const API = `${HOST}/orgs/${ORG}`;
const H   = { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" };

// fetch() does not throw on 401/403/404/500, and an error body has no `data`,
// so an unchecked `r.data?.utterances ?? []` would turn a failure into "no
// speech". Check the status and the shape on every response.
async function getJson(url, init) {
  const res = await fetch(url, init);
  const text = await res.text();
  if (!res.ok) throw new Error(`${res.status} from ${url}: ${text.slice(0, 300)}`);
  const body = JSON.parse(text);
  if (!("data" in body)) throw new Error(`unexpected response shape from ${url}`);
  return body;
}

// Incident filters use gt/lt (exclusive), so bracket the day from one second
// outside it and trim client-side. Transcript windows are inclusive and must
// contain the whole utterance, so pad those by five minutes and trim likewise.
const shift = (d, secs) => new Date(Date.parse(d + "T00:00:00Z") + secs * 1000)
                            .toISOString().replace(/\.\d+/, "");
const lo = shift(day, -1),   hi = shift(day, 86400);
const tLo = shift(day, -300), tHi = shift(day, 86400 + 300);

// List endpoints return at most 100 rows per call; meta.pagination.total is
// always present and drives the loop. An empty page before the total is
// reached is an error, not the end: never return a partial day silently.
async function fetchAll(url, body) {
  const rows = [];
  for (let offset = 0; ; ) {
    const r = await getJson(url, {
      method: "POST", headers: H,
      body: JSON.stringify({ ...body, limit: 100, offset })
    });
    const total = r.meta?.pagination?.total;
    if (total === undefined) throw new Error(`no meta.pagination.total from ${url}`);
    rows.push(...r.data);
    offset += r.data.length;
    if (offset >= total) return rows;
    if (!r.data.length) throw new Error(`${url}: got ${offset} of ${total} rows, then an empty page`);
  }
}

// 1 — incidents that started on the day (note gt/lt, not gte/lte)
const incidents = (await fetchAll(`${API}/incidents/query`, {
  sort: [{ startedAt: "desc" }, { id: "asc" }],
  filter: { startedAt: { gt: lo, lt: hi } }
})).filter(i => i.startedAt.startsWith(day));

// 2 — the presses that belong to those incidents
const presses = incidents.flatMap(i =>
  (i.buttonPushes || []).map(p => ({ incidentId: i.id, ...p })));

// 3 — every utterance from every camera, assigned to the day by startedAt
// An empty deletedAt filter includes cameras since removed; without it they are left out
const cameras = await fetchAll(`${API}/cameras/query`, { filter: { deletedAt: {} }, sort: [{ id: "asc" }] });
const transcripts = {};
for (const cam of cameras) {
  const url = `${API}/cameras/${cam.id}/transcript?start=${tLo}&end=${tHi}`;
  const r = await getJson(url, { headers: H });
  if (!Array.isArray(r.data.utterances)) throw new Error(`no utterances array from ${url}`);
  transcripts[cam.id] = r.data.utterances.filter(u => u.startedAt.startsWith(day));
}

# macOS / Linux (bash or zsh)
export ANTARE_TOKEN=st_…
export ANTARE_ORG_ID=1f0c2a8e-7b3d-4e5f-9a6c-2d8e4b7f1a30
export ANTARE_API_HOST=https://api.eu-west-2.console.antare.ai
python3 antare_export.py 2026-09-28

# Windows (PowerShell)
$env:ANTARE_TOKEN    = "st_…"
$env:ANTARE_ORG_ID   = "1f0c2a8e-7b3d-4e5f-9a6c-2d8e4b7f1a30"
$env:ANTARE_API_HOST = "https://api.eu-west-2.console.antare.ai"
py antare_export.py 2026-09-28

1f0c2a8e-7b3d-4e5f-9a6c-2d8e4b7f1a30 — 2026-09-28 (UTC)
  incidents        3 rows  incidents-2026-09-28.csv
  presses          0 rows  presses-2026-09-28.csv
  transcripts    862 rows  transcripts-2026-09-28.csv

#!/usr/bin/env python3
"""Export one UTC day of incidents, their button presses and all transcripts to CSV.

Standard library only (Python 3.8+). Reads a service token from the environment and
writes three CSVs into the current working directory, replacing them only once every
request has succeeded.

    ANTARE_TOKEN=st_... ANTARE_ORG_ID=... ANTARE_API_HOST=https://api.eu-west-2.console.antare.ai \
        python3 antare_export.py 2026-09-28
"""

import csv
import datetime as dt
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request

TOKEN = os.environ.get("ANTARE_TOKEN", "")
ORG_ID = os.environ.get("ANTARE_ORG_ID", "")
HOST = os.environ.get("ANTARE_API_HOST", "https://api.eu-west-2.console.antare.ai").rstrip("/")
PAGE = 100                      # server-side cap on list endpoints
TIMEOUT = 60                    # seconds per request; transcripts for a long day can be large
PAD = dt.timedelta(minutes=5)   # transcript windows must contain whole utterances


# --- HTTP -----------------------------------------------------------------

def die(msg):
    print("error: " + msg, file=sys.stderr)
    sys.exit(1)


def request(method, url, params=None, body=None, attempt=0):
    """One call. Retries 429 (honoring Retry-After) and 5xx with backoff; everything
    else stops the run with a message that says what to fix."""
    full = url + ("?" + urllib.parse.urlencode(params) if params else "")
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(full, data=data, method=method, headers={
        "Authorization": "Bearer " + TOKEN, "Content-Type": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
            return json.load(r)
    except urllib.error.HTTPError as e:
        detail = e.read()[:300].decode(errors="replace")
        if e.code == 401:
            die("401 unauthenticated — the service token was rejected. It may have\n"
                "       expired or the service may have been deleted; create a new\n"
                "       service under Manage → Services in the console.")
        if e.code == 403:
            if "cannot access endpoint" in detail:
                die("403 — this endpoint is not open to service tokens:\n       " + full)
            die("403 forbidden — the service's roles lack permission for\n"
                "       %s\n       Give the service a role with View devices and "
                "View events." % full)
        if e.code == 404:
            die("404 not found — wrong org id, or the wrong regional host for it: " + full)
        if e.code in (429, 500, 502, 503, 504) and attempt < 5:
            wait = 2 ** attempt                               # 1, 2, 4, 8, 16 s
            if e.code == 429 and e.headers.get("Retry-After", "").isdigit():
                wait = max(wait, int(e.headers["Retry-After"]))
            print("  %d from server; retrying in %ds" % (e.code, wait), file=sys.stderr)
            time.sleep(wait)
            return request(method, url, params, body, attempt + 1)
        die("%d from %s\n       %s" % (e.code, full, detail))
    except (urllib.error.URLError, TimeoutError, OSError) as e:
        if attempt < 5:
            wait = 2 ** attempt
            print("  could not reach %s (%s); retrying in %ds" % (HOST, e, wait), file=sys.stderr)
            time.sleep(wait)
            return request(method, url, params, body, attempt + 1)
        die("could not reach %s after several attempts: %s\n"
            "       Check the host, your network and any proxy." % (HOST, e))


def paginate(url, body=None):
    """Walk an offset-paginated collection, 100 rows at a time.

    A full page is not the end of the data and the response never says it
    truncated; meta.pagination.total is always present and drives the loop.
    If it were missing, or a page came back empty early, stop loudly rather than
    export a partial day."""
    rows, offset = [], 0
    while True:
        if body is None:
            r = request("GET", url, params={"offset": offset, "limit": PAGE})
        else:
            r = request("POST", url, body=dict(body, limit=PAGE, offset=offset))
        page = r.get("data") or []
        rows += page
        total = (r.get("meta") or {}).get("pagination", {}).get("total")
        if total is None:
            die("response from %s had no meta.pagination.total; refusing to guess "
                "whether the export is complete" % url)
        offset += len(page)
        if offset >= total:
            return rows
        if not page:
            die("%s returned an empty page after %d of %d rows; refusing to export a "
                "partial day" % (url, offset, total))


# --- day boundaries -------------------------------------------------------

def iso(t):
    return t.strftime("%Y-%m-%dT%H:%M:%SZ")


def day_bounds(day):
    """(midnight, next midnight) of a UTC day as aware datetimes."""
    d = dt.date.fromisoformat(day)
    start = dt.datetime.combine(d, dt.time(), dt.timezone.utc)
    return start, start + dt.timedelta(days=1)


def on_day(rows, field, day):
    return [r for r in rows if (r.get(field) or "").startswith(day)]


# --- export ---------------------------------------------------------------

def main():
    if not TOKEN.startswith("st_"):
        die("set ANTARE_TOKEN to a service token from Manage → Services in the console")
    if not ORG_ID:
        die("set ANTARE_ORG_ID to your organization's id (a UUID supplied by Antare)")
    day = sys.argv[1] if len(sys.argv) > 1 else str(dt.datetime.now(dt.timezone.utc).date())
    start, end = day_bounds(day)
    base = "%s/orgs/%s" % (HOST, ORG_ID)
    print("%s — %s (UTC)" % (ORG_ID, day), file=sys.stderr)

    staged = []

    def write(name, header, rows):
        """Write to a temporary file. publish() renames them all at the end, so a
        request failure leaves the previous export intact. The renames themselves
        happen one file at a time and are not atomic as a set."""
        path = "%s-%s.csv" % (name, day)
        with open(path + ".tmp", "w", newline="", encoding="utf-8") as f:
            w = csv.writer(f)
            w.writerow(header)
            w.writerows(rows)
        staged.append((path + ".tmp", path, len(rows)))

    def publish():
        for tmp, path, n in staged:
            os.replace(tmp, path)
            print("  %-12s %5d rows  %s" % (path.split("-")[0], n, path), file=sys.stderr)

    # 1 — incidents that started on the day. gt/lt are exclusive, so the bounds
    #     sit one second outside the day and rows are trimmed to it.
    incidents = on_day(paginate(base + "/incidents/query", {
        "sort": [{"startedAt": "desc"}, {"id": "asc"}],
        "filter": {"startedAt": {"gt": iso(start - dt.timedelta(seconds=1)), "lt": iso(end)}},
    }), "startedAt", day)
    write("incidents",
          ["id", "started_at", "ended_at", "severity", "type", "title", "camera_ids"],
          [[i["id"], i.get("startedAt"), i.get("endedAt"), i.get("severity"),
            i.get("incidentType"), text_of(i.get("title")), " ".join(camera_ids(i))]
           for i in incidents])

    # 2 — the button presses that belong to those incidents (not every physical press)
    write("presses", ["incident_id", "camera_id", "button_id", "pushed_at"],
          [[i["id"], p.get("cameraId"), p.get("buttonId"), p.get("pushedAt")]
           for i in incidents for p in (i.get("buttonPushes") or [])])

    # 3 — every utterance from every camera, including cameras since deleted.
    #     The window is inclusive and must contain the whole utterance, so it is
    #     padded, and utterances are assigned to the day by startedAt.
    cameras = paginate(base + "/cameras/query", {"filter": {"deletedAt": {}}, "sort": [{"id": "asc"}]})
    rows = []
    for cam in cameras:
        data = request("GET", "%s/cameras/%s/transcript" % (base, cam["id"]),
                       params={"start": iso(start - PAD), "end": iso(end + PAD)})["data"]
        for u in on_day(data.get("utterances") or [], "startedAt", day):
            rows.append([cam["id"], cam.get("name"), u["startedAt"], u["endedAt"],
                         u.get("speaker"), (u.get("fragment") or "").replace("\n", " ").strip()])
    write("transcripts",
          ["camera_id", "camera", "started_at", "ended_at", "speaker", "text"], rows)
    publish()


def text_of(rich):
    """title and summaryShort are {"data": [{"text": ...}]}, not strings."""
    return "".join(part.get("text") or "" for part in (rich or {}).get("data") or [])


def camera_ids(incident):
    """A camera is nested under media[]; either key may be the populated one."""
    out = []
    for m in incident.get("media") or []:
        cam = m.get("camera") or m.get("liveCamera")
        if cam and cam.get("id"):
            out.append(cam["id"])
    return sorted(set(out))


if __name__ == "__main__":
    main()

{
  "data": [ … ],
  "meta": {
    "pagination": { "total": 27, "currentPage": 2, "totalPages": 3 }
  }
}