CoveredLoop HTTP API Reference

const res = await fetch("https://coveredloop.com/api/health");
const body = await res.json();
if (!body.ok) throw new Error("CoveredLoop is down");

import requests
r = requests.get("https://coveredloop.com/api/health", timeout=10)
r.raise_for_status()
print(r.json())  # {'ok': True, 'status': 'up', 'time': '...'}

const res = await fetch("https://coveredloop.com/api/health/deep", {
  headers: { Authorization: `Bearer ${ownerApiToken}` },
  credentials: "include",
});
console.log(await res.json());

import os, requests
r = requests.get(
    "https://coveredloop.com/api/health/deep",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_OWNER_TOKEN']}"},
    timeout=10,
)
print(r.json())

const res = await fetch("https://coveredloop.com/api/auth/sign-up/email", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  credentials: "include",
  body: JSON.stringify({
    email: "trader@example.com",
    password: "••••••••",
    name: "Alex Trader",
    callbackURL: "/app",
  }),
});

import requests
r = requests.post(
    "https://coveredloop.com/api/auth/sign-up/email",
    json={"email": "trader@example.com", "password": "••••••••", "name": "Alex Trader"},
    timeout=15,
)
print(r.status_code, r.json())

const res = await fetch("https://coveredloop.com/api/auth/sign-in/email", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  credentials: "include",
  body: JSON.stringify({ email: "trader@example.com", password: "••••••••" }),
});
const data = await res.json();
if (data.twoFactorRedirect) location.href = "/two-factor";

import requests
s = requests.Session()
r = s.post(
    "https://coveredloop.com/api/auth/sign-in/email",
    json={"email": "trader@example.com", "password": "••••••••"},
    timeout=15,
)
print(r.json())

const res = await fetch("https://coveredloop.com/api/auth/get-session", { credentials: "include" });
const { user } = await res.json();

import requests
r = requests.get("https://coveredloop.com/api/auth/get-session", cookies=session_cookies, timeout=10)
print(r.json().get("user"))

await fetch("https://coveredloop.com/api/auth/sign-out", { method: "POST", credentials: "include" });

requests.post("https://coveredloop.com/api/auth/sign-out", cookies=session_cookies, timeout=10)

await fetch("https://coveredloop.com/api/auth/forget-password", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ email: "trader@example.com", redirectTo: "/reset-password" }),
});

requests.post(
    "https://coveredloop.com/api/auth/forget-password",
    json={"email": "trader@example.com", "redirectTo": "/reset-password"},
    timeout=15,
)

await fetch("https://coveredloop.com/api/auth/reset-password", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ token, newPassword }),
});

requests.post(
    "https://coveredloop.com/api/auth/reset-password",
    json={"token": token, "newPassword": new_password},
    timeout=15,
)

// Prefer the emailed link. To resend:
await fetch("https://coveredloop.com/api/auth/send-verification-email", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  credentials: "include",
  body: JSON.stringify({ email: "trader@example.com", callbackURL: "/app" }),
});

requests.get(
    "https://coveredloop.com/api/auth/verify-email",
    params={"token": token, "callbackURL": "/app"},
    allow_redirects=False,
    timeout=15,
)

await fetch("https://coveredloop.com/api/auth/two-factor/verify-totp", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  credentials: "include",
  body: JSON.stringify({ code: "123456" }),
});

s.post("https://coveredloop.com/api/auth/two-factor/verify-totp", json={"code": "123456"}, timeout=10)

const res = await fetch("https://coveredloop.com/api/v1/connect", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ action: "start", name: "my-bot" }),
});

import requests
requests.post(
    "https://coveredloop.com/api/v1/connect",
    json={"action": "start", "name": "my-bot"},
    timeout=15,
)

const res = await fetch("https://coveredloop.com/api/v1/connect", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ action: "poll", device_code: deviceCode }),
});

import requests
requests.post(
    "https://coveredloop.com/api/v1/connect",
    json={"action": "poll", "device_code": device_code},
    timeout=15,
)

const res = await fetch("https://coveredloop.com/api/v1/me", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
console.log(await res.json());

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/me",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=15,
)
print(r.json())

const res = await fetch("https://coveredloop.com/api/v1/membership", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/membership",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=15,
)

const res = await fetch("https://coveredloop.com/api/v1/portfolio", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const book = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/portfolio",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=30,
)
print(r.json()["summary"])

const res = await fetch("https://coveredloop.com/api/v1/dashboard?range=1M", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const dash = await res.json();
const equity = dash.summary.find((b) => b.id === "total_equity");

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/dashboard",
    params={"range": "1M"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=30,
)
book = r.json()
print(book["summary"])
for acct in book["accounts"]:
    print(acct["id"], acct["summary"])

const res = await fetch("https://coveredloop.com/api/v1/reports?format=pdf&from=2026-01-01", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const blob = await res.blob();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/reports",
    params={"format": "xlsx", "from": "2026-01-01", "status": "closed"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=60,
)
open("CoveredLoop-Report.xlsx", "wb").write(r.content)

const res = await fetch("https://coveredloop.com/api/v1/accounts", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/accounts",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/sync", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.post(
    "https://coveredloop.com/api/v1/sync",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=60,
)

const res = await fetch("https://coveredloop.com/api/v1/holdings", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/holdings",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/trades?status=open", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/trades",
    params={"status": "open", "limit": 50},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/watchlists", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { watchlists } = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/watchlists",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)
print(r.json()["count"])

const res = await fetch(`https://coveredloop.com/api/v1/watchlists/${listId}`, {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { watchlist } = await res.json();

import os, requests
r = requests.get(
    f"https://coveredloop.com/api/v1/watchlists/{list_id}",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)
print(r.json()["watchlist"]["items"])

const res = await fetch("https://coveredloop.com/api/v1/alerts?status=active", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { alerts } = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/alerts",
    params={"status": "active"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)
print(r.json()["total"])

const res = await fetch(`https://coveredloop.com/api/v1/alerts/${alertId}`, {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    f"https://coveredloop.com/api/v1/alerts/{alert_id}",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=15,
)

const res = await fetch("https://coveredloop.com/api/v1/alerts/trade", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { prefs } = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/alerts/trade",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=15,
)
print(r.json()["prefs"]["enabled"])

const res = await fetch("https://coveredloop.com/api/v1/pl/calendar?from=2026-08-01", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const cal = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/pl/calendar",
    params={"from": "2026-08-01", "to": "2026-08-30"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=30,
)
print(r.json()["totals"])

const res = await fetch("https://coveredloop.com/api/v1/pl/day?date=2026-08-28", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/day",
    params={"date": "2026-08-28"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/pl/months?from=2026-01-01", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/months",
    params={"from": "2026-01-01"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=30,
)

const res = await fetch("https://coveredloop.com/api/v1/pl/opened?from=2026-08-01", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/opened",
    params={"from": "2026-08-01"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/pl/summary?from=2026-01-01", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/summary",
    params={"from": "2026-01-01"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/pl/distribution?dimension=strategy", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/distribution",
    params={"dimension": "strategy"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/pl/series?grain=month", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/pl/series",
    params={"grain": "month"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/metrics", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/metrics",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=30,
)

const res = await fetch("https://coveredloop.com/api/v1/metrics/summary", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/metrics/summary",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/metrics/trade", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/metrics/trade",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/metrics/quality", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/metrics/quality",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/metrics/risk", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/v1/metrics/risk",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)

const res = await fetch("https://coveredloop.com/api/v1/positions?flattenable=1", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { positions } = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/positions",
    params={"flattenable": "1"},
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)
print(r.json()["positions"])

const headers = {
  Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}`,
  "Content-Type": "application/json",
};
const preview = await fetch("https://coveredloop.com/api/v1/positions/flatten", {
  method: "POST",
  headers,
  body: JSON.stringify({ positionId, type: "limit", price: 0.45 }),
});
const body = await preview.json();
if (!body.dryRun) throw new Error("expected preview");
// Only then, with an explicit confirm from your rules:
const live = await fetch("https://coveredloop.com/api/v1/positions/flatten", {
  method: "POST",
  headers,
  body: JSON.stringify({ positionId, type: "market", dryRun: false, confirm: true }),
});

import os, requests
h = {"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"}
preview = requests.post(
    "https://coveredloop.com/api/v1/positions/flatten",
    headers=h,
    json={"positionId": position_id, "type": "limit", "price": 0.45},
    timeout=30,
)
print(preview.json()["preview"])
# live = requests.post(..., json={..., "dryRun": False, "confirm": True})

const res = await fetch("https://coveredloop.com/api/v1/orders", {
  headers: { Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}` },
});
const { orders } = await res.json();

import os, requests
r = requests.get(
    "https://coveredloop.com/api/v1/orders",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    timeout=20,
)
print(r.json()["orders"])

const headers = {
  Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}`,
  "Content-Type": "application/json",
};
const ticket = {
  class: "spread",
  accountId,
  underlying: "SPX",
  type: "credit",
  price: 1.2,
  legs: [
    { side: "sell_to_open", quantity: 1, optionSymbol: shortOcc },
    { side: "buy_to_open", quantity: 1, optionSymbol: longOcc },
  ],
};
const preview = await fetch("https://coveredloop.com/api/v1/orders", {
  method: "POST",
  headers,
  body: JSON.stringify(ticket),
});
const body = await preview.json();
if (!body.dryRun) throw new Error("expected preview");

import os, requests
h = {"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"}
preview = requests.post(
    "https://coveredloop.com/api/v1/orders",
    headers=h,
    json={
        "class": "equity",
        "accountId": account_id,
        "symbol": "MRVL",
        "quantity": 100,
        "side": "buy",
        "type": "limit",
        "price": 80.5,
    },
    timeout=30,
)
print(preview.json()["preview"])

await fetch("https://coveredloop.com/api/v1/orders/cancel", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ accountId, orderId, dryRun: false, confirm: true }),
});

import os, requests
requests.post(
    "https://coveredloop.com/api/v1/orders/cancel",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    json={"accountId": account_id, "orderId": order_id, "dryRun": False, "confirm": True},
    timeout=20,
)

await fetch("https://coveredloop.com/api/v1/orders/change", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.COVEREDLOOP_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ accountId, orderId, type: "limit", price: 1.05, dryRun: false, confirm: true }),
});

import os, requests
requests.post(
    "https://coveredloop.com/api/v1/orders/change",
    headers={"Authorization": f"Bearer {os.environ['COVEREDLOOP_TOKEN']}"},
    json={"accountId": account_id, "orderId": order_id, "type": "limit", "price": 1.05, "dryRun": False, "confirm": True},
    timeout=20,
)

import { createHmac } from "node:crypto";
const body = JSON.stringify({
  channel: "android",
  kind: "renewal",
  userId,
  planId: "monthly",
  storeTxId,
  amountCents: 2900,
});
const ts = Math.floor(Date.now() / 1000);
const sig = createHmac("sha256", process.env.STORE_WEBHOOK_SECRET)
  .update(`${ts}.${body}`)
  .digest("hex");
await fetch("https://coveredloop.com/api/billing/store-notify", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.STORE_WEBHOOK_SECRET}`,
    "X-CoveredLoop-Timestamp": String(ts),
    "X-CoveredLoop-Signature": `sha256=${sig}`,
    "Content-Type": "application/json",
  },
  body,
});

import os, requests
r = requests.post(
    "https://coveredloop.com/api/billing/store-notify",
    headers={"Authorization": f"Bearer {os.environ['STORE_WEBHOOK_SECRET']}"},
    json={
        "channel": "ios",
        "kind": "purchase",
        "userId": user_id,
        "planId": "annual",
        "storeTxId": store_tx_id,
        "amountCents": 19900,
    },
    timeout=15,
)
r.raise_for_status()

await fetch("https://coveredloop.com/api/cron/live-books", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/live-books",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=60,
)

await fetch("https://coveredloop.com/api/cron/live-books-rebuild", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/live-books-rebuild",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=300,
)

await fetch("https://coveredloop.com/api/cron/health-watch?heartbeat=1", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/health-watch",
    params={"heartbeat": "1"},
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=30,
)

await fetch("https://coveredloop.com/api/cron/email-reports", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/email-reports",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=60,
)

await fetch("https://coveredloop.com/api/cron/membership-renewals", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/membership-renewals",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=60,
)

await fetch("https://coveredloop.com/api/cron/market-quotes", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/market-quotes",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=60,
)

await fetch("https://coveredloop.com/api/cron/sample-roll", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/sample-roll",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=30,
)

await fetch("https://coveredloop.com/api/cron/store-settlements", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/store-settlements",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=30,
)

await fetch("https://coveredloop.com/api/cron/audit-retention", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/audit-retention",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=30,
)

await fetch("https://coveredloop.com/api/cron/kb-pending-reminder", {
  headers: { Authorization: `Bearer ${process.env.CRON_SECRET}` },
});

import os, requests
requests.get(
    "https://coveredloop.com/api/cron/kb-pending-reminder",
    headers={"Authorization": f"Bearer {os.environ['CRON_SECRET']}"},
    timeout=30,
)

await fetch("http://127.0.0.1:8080/api/dev/verify-email", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.DEV_VERIFY_SECRET}`,
  },
  body: JSON.stringify({ email: "dev@example.com" }),
});

import os, requests
requests.post(
    "http://127.0.0.1:8080/api/dev/verify-email",
    json={"email": "dev@example.com"},
    headers={"Authorization": f"Bearer {os.environ['DEV_VERIFY_SECRET']}"},
    timeout=10,
)