A Good API
for Bad News

# 1. Discover all tracked crises
curl -H "Authorization: Bearer $POLYCRISIS_KEY" \
  https://polycrisis.world/api/v1/crises

# 2. Iran military events, last 24h
curl -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/events?crisis=iran&type=military&limit=10"

# 3. Current intensity index for Iran (with 30d timeseries)
curl -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/intensity?crisis=iran&window=30"

# 4. Scenario probabilities for Iran
curl -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/scenarios?crisis=iran"

# 5. Stream events in real time (SSE) — Developer tier
curl -N -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/stream?crisis=iran"

import os, requests

API = "https://polycrisis.world/api/v1"
HEAD = {"Authorization": f"Bearer {os.environ['POLYCRISIS_KEY']}"}

# 1. Discover all tracked crises
crises = requests.get(f"{API}/crises", headers=HEAD).json()["crises"]

# 2. Iran military events, last 24h
events = requests.get(
    f"{API}/events",
    headers=HEAD,
    params={"crisis": "iran", "type": "military", "limit": 10},
).json()["events"]

# 3. Current intensity index for Iran
idx = requests.get(
    f"{API}/intensity",
    headers=HEAD,
    params={"crisis": "iran", "window": 30},
).json()["current_index"]

# 4. Scenario probabilities for Iran
scenarios = requests.get(
    f"{API}/scenarios",
    headers=HEAD,
    params={"crisis": "iran"},
).json()["scenarios"]

print(f"Tracking {len(crises)} crises")
print(f"Iran intensity: {idx['value']} [{idx['band']}]")
for s in scenarios[:3]:
    print(f"  {s['title']}: {s['probability']}% [{s['band']}]")

import fetch from 'node-fetch';

const API = 'https://polycrisis.world/api/v1';
const HEAD = { 'Authorization': `Bearer ${process.env.POLYCRISIS_KEY}` };

// 1. Discover all tracked crises
const { crises } = await (await fetch(`${API}/crises`, { headers: HEAD })).json();

// 2. Iran military events, last 24h
const { events } = await (await fetch(
  `${API}/events?crisis=iran&type=military&limit=10`,
  { headers: HEAD }
)).json();

// 3. Current intensity index for Iran
const { current_index } = await (await fetch(
  `${API}/intensity?crisis=iran&window=30`,
  { headers: HEAD }
)).json();

// 4. Scenario probabilities for Iran
const { scenarios } = await (await fetch(
  `${API}/scenarios?crisis=iran`,
  { headers: HEAD }
)).json();

console.log(`Tracking ${crises.length} crises`);
console.log(`Iran intensity: ${current_index.value} [${current_index.band}]`);
scenarios.slice(0, 3).forEach(s => {
  console.log(`  ${s.title}: ${s.probability}% [${s.band}]`);
});

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

const API = "https://polycrisis.world/api/v1"

func get(path string) map[string]interface{} {
    req, _ := http.NewRequest("GET", API+path, nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("POLYCRISIS_KEY"))
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    var out map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&out)
    return out
}

func main() {
    crises := get("/crises")
    events := get("/events?crisis=iran&type=military&limit=10")
    idx := get("/intensity?crisis=iran&window=30")
    scens := get("/scenarios?crisis=iran")

    fmt.Printf("crises: %d\n", len(crises["crises"].([]interface{})))
    fmt.Printf("events: %d\n", len(events["events"].([]interface{})))
    fmt.Printf("intensity: %v\n", idx["current_index"])
    fmt.Printf("scenarios: %d\n", len(scens["scenarios"].([]interface{})))
}

# Check Iran intensity every 5 minutes
while true; do
  curl -s -H "Authorization: Bearer $POLYCRISIS_KEY" \
    "https://polycrisis.world/api/v1/intensity?crisis=iran&window=30" \
    | jq '.current_index | "\(.value) [\(.band)] \(.delta_7d)"'
  sleep 300
done

import os, time, requests

API = "https://polycrisis.world/api/v1"
HEAD = {"Authorization": f"Bearer {os.environ['POLYCRISIS_KEY']}"}

def check_iran():
    r = requests.get(
        f"{API}/intensity",
        headers=HEAD,
        params={"crisis": "iran", "window": 30},
    ).json()
    idx = r["current_index"]
    return idx["value"], idx["band"], idx["delta_7d"]

while True:
    value, band, delta = check_iran()
    if value > 7 and delta > 0:
        reduce_equity_exposure()  # your trading logic
    print(f"iran: {value} [{band}] {delta:+.1f}")
    time.sleep(300)

# Iran military event detected — where does it connect?
curl -s -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/connections?crisis=iran" \
  | jq '.connections[] | select(.strength > 0.6)'

# Example match: iran → scs, strength 0.71, mechanisms: energy chokepoint
# Action: build shipping/energy positions on the secondary theater

import os, requests

API = "https://polycrisis.world/api/v1"
HEAD = {"Authorization": f"Bearer {os.environ['POLYCRISIS_KEY']}"}

# Iran spiked — where do the secondary effects hit?
data = requests.get(
    f"{API}/connections",
    headers=HEAD,
    params={"crisis": "iran"},
).json()

for c in data["connections"]:
    if c["strength"] > 0.6:
        print(f"{c['source_crisis']} → {c['target_crisis']}: "
              f"strength {c['strength']}, via {c['mechanisms']}")
        # queue_position(c['target_crisis'], horizon_days=14)

# Register an intensity-spike webhook for Iran
curl -X POST -H "Authorization: Bearer $POLYCRISIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhook",
    "triggers": ["new_event", "scenario_change", "intensity_spike"],
    "crisis": "iran",
    "intensity_threshold": 7
  }' \
  https://polycrisis.world/api/v1/webhooks

# Response includes signing_secret — store it to verify inbound deliveries

import os, requests

API = "https://polycrisis.world/api/v1"
HEAD = {
    "Authorization": f"Bearer {os.environ['POLYCRISIS_KEY']}",
    "Content-Type": "application/json",
}

hook = requests.post(
    f"{API}/webhooks",
    headers=HEAD,
    json={
        "url": "https://your-app.com/webhook",
        "triggers": ["new_event", "scenario_change", "intensity_spike"],
        "crisis": "iran",
        "intensity_threshold": 7,
    },
).json()

# Store signing_secret securely — you'll need it to HMAC-verify deliveries
secret = hook["signing_secret"]
print(f"registered: {hook['id']}")

# What does the current week look like historically?
curl -s -H "Authorization: Bearer $POLYCRISIS_KEY" \
  "https://polycrisis.world/api/v1/analogs?crisis=iran" \
  | jq '.analogs[0]'

import os, requests

API = "https://polycrisis.world/api/v1"
HEAD = {"Authorization": f"Bearer {os.environ['POLYCRISIS_KEY']}"}

data = requests.get(
    f"{API}/analogs",
    headers=HEAD,
    params={"crisis": "iran"},
).json()

for a in data["analogs"][:3]:
    print(f"{a['period']}: similarity {a['similarity']:.2f}")
    print(f"  outcome: {a.get('outcome', 'n/a')}")
    # a['market_outcome'] has tickers → returns