SiliconANALYSIS API

curl https://www.siliconanalysis.com/api/v1/companies \
  -H "Authorization: Bearer $SA_API_KEY"

import os, httpx

r = httpx.get(
    "https://www.siliconanalysis.com/api/v1/companies",
    headers={"Authorization": f"Bearer {os.environ['SA_API_KEY']}"},
)
r.raise_for_status()
for co in r.json()["data"][:5]:
    print(co["ticker"], co["latestAlpha"], co["alphaChange24h"])

const res = await fetch("https://www.siliconanalysis.com/api/v1/companies", {
  headers: { Authorization: `Bearer ${process.env.SA_API_KEY}` },
});
const { data } = await res.json();
for (const co of data.slice(0, 5)) {
  console.log(co.ticker, co.latestAlpha, co.alphaChange24h);
}

curl "https://www.siliconanalysis.com/api/v1/scores?ticker=NVDA&days=90" \
  -H "Authorization: Bearer $SA_API_KEY"

import os, httpx, pandas as pd

r = httpx.get(
    "https://www.siliconanalysis.com/api/v1/scores",
    params={"ticker": "NVDA", "days": 90},
    headers={"Authorization": f"Bearer {os.environ['SA_API_KEY']}"},
)
df = pd.DataFrame(r.json()["data"])
df["asOf"] = pd.to_datetime(df["asOf"])
print(df[["asOf", "alpha", "alphaNews", "alphaMomentum"]].tail())

const url = new URL("https://www.siliconanalysis.com/api/v1/scores");
url.searchParams.set("ticker", "NVDA");
url.searchParams.set("days", "90");

const res = await fetch(url, {
  headers: { Authorization: `Bearer ${process.env.SA_API_KEY}` },
});
const { data } = await res.json();
console.log(`${data.length} score snapshots for NVDA`);
console.log(data.at(-1)); // latest

curl "https://www.siliconanalysis.com/api/v1/capex?ticker=MSFT" \
  -H "Authorization: Bearer $SA_API_KEY"

import os, httpx

r = httpx.get(
    "https://www.siliconanalysis.com/api/v1/capex",
    params={"ticker": "MSFT"},
    headers={"Authorization": f"Bearer {os.environ['SA_API_KEY']}"},
)
for q in r.json()["data"]:
    total_b = (q["totalCapex"] or 0) / 1000
    ai_b = (q["aiCapex"] or 0) / 1000
    print(f"{q['fiscalQuarter']} {q['fiscalYear']}: total ${total_b:.1f}B  AI ${ai_b:.1f}B  YoY {q['capexYoY']}%")

const url = new URL("https://www.siliconanalysis.com/api/v1/capex");
url.searchParams.set("ticker", "MSFT");

const res = await fetch(url, {
  headers: { Authorization: `Bearer ${process.env.SA_API_KEY}` },
});
const { data } = await res.json();
for (const q of data) {
  const totalB = (q.totalCapex ?? 0) / 1000;
  const aiB = (q.aiCapex ?? 0) / 1000;
  console.log(`${q.fiscalQuarter} ${q.fiscalYear}: total $${totalB.toFixed(1)}B  AI $${aiB.toFixed(1)}B  YoY ${q.capexYoY}%`);
}

curl -X POST https://www.siliconanalysis.com/api/v1/webhooks \
  -H "Authorization: Bearer $SA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hooks.slack.com/services/T.../B.../...",
    "name": "prod-slack-bridge",
    "events": ["alert.fired", "capex.published"]
  }'

import os, httpx

r = httpx.post(
    "https://www.siliconanalysis.com/api/v1/webhooks",
    headers={"Authorization": f"Bearer {os.environ['SA_API_KEY']}"},
    json={
        "url": "https://hooks.slack.com/services/T.../B.../...",
        "name": "prod-slack-bridge",
        "events": ["alert.fired", "capex.published"],
    },
)
r.raise_for_status()
created = r.json()
print("webhook id:", created["data"]["id"])
print("SAVE THIS NOW:", created["secret"])  # plaintext, shown once

const res = await fetch("https://www.siliconanalysis.com/api/v1/webhooks", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SA_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    url: "https://hooks.slack.com/services/T.../B.../...",
    name: "prod-slack-bridge",
    events: ["alert.fired", "capex.published"],
  }),
});
const created = await res.json();
console.log("webhook id:", created.data.id);
console.log("SAVE THIS NOW:", created.secret); // plaintext, shown once

import hmac, hashlib, time
from fastapi import FastAPI, Request, Header, HTTPException

SECRET = os.environ["SA_WEBHOOK_SECRET"]  # whsec_… plaintext you saved at register time
TOLERANCE_SECONDS = 300  # reject deliveries older than 5 min

app = FastAPI()

@app.post("/sa-webhook")
async def receive(
    request: Request,
    x_sa_signature: str = Header(...),
    x_sa_event_id: str = Header(...),
):
    body_bytes = await request.body()
    # Parse "t=<ms>,v1=<hex>"
    parts = dict(p.split("=", 1) for p in x_sa_signature.split(","))
    ts_ms = int(parts["t"]); sig = parts["v1"]

    # Reject stale deliveries.
    if abs(time.time() * 1000 - ts_ms) > TOLERANCE_SECONDS * 1000:
        raise HTTPException(400, "timestamp_outside_tolerance")

    # Recompute HMAC over "<ts>.<body>" and constant-time compare.
    expected = hmac.new(
        SECRET.encode(),
        f"{ts_ms}.".encode() + body_bytes,
        hashlib.sha256,
    ).hexdigest()
    if not hmac.compare_digest(expected, sig):
        raise HTTPException(401, "signature_mismatch")

    # Dedupe on x_sa_event_id — retries reuse the same key.
    payload = await request.json()
    print(payload["eventType"], payload["data"])
    return {"ok": True}

import { createHmac, timingSafeEqual } from "crypto";
import express from "express";

const SECRET = process.env.SA_WEBHOOK_SECRET!;  // whsec_… plaintext
const TOLERANCE_SECONDS = 300;

const app = express();

// Capture RAW body — JSON middleware would mutate it and break the signature.
app.use("/sa-webhook", express.raw({ type: "application/json" }));

app.post("/sa-webhook", (req, res) => {
  const sig = String(req.header("x-sa-signature") ?? "");
  const eventId = String(req.header("x-sa-event-id") ?? "");
  const parts = Object.fromEntries(sig.split(",").map((kv) => kv.split("=")));
  const tsMs = Number(parts.t);
  const v1 = String(parts.v1 ?? "");

  if (!tsMs || !v1) return res.status(400).send("malformed_signature_header");
  if (Math.abs(Date.now() - tsMs) > TOLERANCE_SECONDS * 1000) {
    return res.status(400).send("timestamp_outside_tolerance");
  }

  const body: Buffer = req.body;
  const expected = createHmac("sha256", SECRET)
    .update(`${tsMs}.`)
    .update(body)
    .digest("hex");
  const a = Buffer.from(expected, "hex");
  const b = Buffer.from(v1, "hex");
  if (a.length !== b.length || !timingSafeEqual(a, b)) {
    return res.status(401).send("signature_mismatch");
  }

  // Dedupe on eventId — retries reuse the same key.
  const payload = JSON.parse(body.toString("utf8"));
  console.log(payload.eventType, payload.data);
  res.status(200).send({ ok: true });
});