Quickstart

In the next five minutes you’ll go from nothing to a live structured view of the global conversation: the top terms driving it, the editorial summary of the dominant storyline, and the most recent volume-spike alert. Same key, three calls, no setup. By the end of this page you will have:

a working trial API key (free, 7 days, no credit card),
a Python script that prints what’s trending on global right now,
a second script that pulls the latest narrative and the loudest recent alert,
enough understanding of the response shapes to build something real.

If you’d rather skim before you type, the home page shows live response samples, and Use cases has five ready-made recipes.

What you’ll be calling

Three endpoints, all Watch-tier, all available on a free trial key, all keyed on the global curated topic:

Endpoint	Returns	Why you care
`GET /v1/topics/global/trending`	Top terms by rolling z-score	The signal: which terms are spiking right now
`GET /v1/topics/global/narrative`	Editorial summary + sub-narrative weights	The story: what is actually being said
`GET /v1/topics/global/alerts`	LLM-validated volume spikes with severity, spread, IOCs	The push-shaped event signal — see Alerts for the full envelope

Curated topics are the named, stable slices Exorde maintains: global, cyber, finance, disinfo. Trial keys are scoped to global only — paid tiers unlock the other three. See Topics and watchlists and Tiers.

Step 1 — Mint a trial key

One unauthenticated POST. Idempotent per email: call it twice with the same address inside the 7-day window and you get the same key back with reused: true. No duplicate keys.

curl -X POST https://intel-v1.exorde.io/v1/keys/trial \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}'

import httpx

r = httpx.post(
    "https://intel-v1.exorde.io/v1/keys/trial",
    json={"email": "[email protected]"},
    timeout=10,
)
r.raise_for_status()
api_key = r.json()["api_key"]
print(api_key)

const r = await fetch("https://intel-v1.exorde.io/v1/keys/trial", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ email: "[email protected]" }),
});
const data = await r.json();
console.log(data.api_key);

$body = @{ email = "[email protected]" } | ConvertTo-Json
$r = Invoke-RestMethod `
  -Method Post `
  -Uri "https://intel-v1.exorde.io/v1/keys/trial" `
  -ContentType "application/json" `
  -Body $body
$r.api_key

The response includes everything your code needs to know about the key it just got:

{
  "api_key": "exd_trial_QLocUNNcjQ7TXxTgJZ2DWww4QxjlLBgc",
  "client_id": "trial_3c91be7f",
  "tier": "watch",
  "topics": ["global"],
  "rate_limit_rpm": 30,
  "monthly_call_quota": 5000,
  "expires_at": "2026-05-26T13:00:00Z",
  "reused": false
}

Watch-tier, 30 RPM, global only, expires in 7 days. Full lifecycle (rotate, revoke, re-mint) is in Authentication.

Step 2 — Save it once, use it everywhere

Every authenticated request carries X-API-Key. Export the key as an environment variable so the snippets below work as-is.

export EXORDE_API_KEY="exd_trial_..."

$env:EXORDE_API_KEY = "exd_trial_..."

[Environment]::SetEnvironmentVariable("EXORDE_API_KEY", "exd_trial_...", "User")

Treat keys like passwords. Never commit them, never embed them in a public SPA bundle, never email in plaintext. If a key leaks, rotate it — atomic, free, instantaneous.

The trending endpoint returns the top terms ranked by rolling z-score over the latest snapshot, deduped, with 24-hour delta.

curl https://intel-v1.exorde.io/v1/topics/global/trending \
  -H "X-API-Key: $EXORDE_API_KEY"

import os, httpx

r = httpx.get(
    "https://intel-v1.exorde.io/v1/topics/global/trending",
    headers={"X-API-Key": os.environ["EXORDE_API_KEY"]},
    timeout=10,
)
r.raise_for_status()

for t in r.json()["terms"][:10]:
    print(f"{t['rank']:>2}. {t['term']:<25} z={t['score']:>7.1f}  Δ24h={t['delta_24h']:+.1f}")

const r = await fetch(
  "https://intel-v1.exorde.io/v1/topics/global/trending",
  { headers: { "X-API-Key": process.env.EXORDE_API_KEY } }
);
const data = await r.json();
data.terms.slice(0, 10).forEach(t =>
  console.log(`${t.rank}. ${t.term} z=${t.score.toFixed(1)} Δ24h=${t.delta_24h}`)
);

$r = Invoke-RestMethod `
  -Uri "https://intel-v1.exorde.io/v1/topics/global/trending" `
  -Headers @{ "X-API-Key" = $env:EXORDE_API_KEY }
$r.terms | Select-Object -First 10 rank, term, score, delta_24h | Format-Table

A real response looks like this:

{
  "topic": "global",
  "snapshot_id": "2026-05-19T13:00:00Z",
  "terms": [
    { "term": "Iran",       "score": 847.2, "rank": 1, "delta_24h": 6.6 },
    { "term": "Eurovision", "score": 412.0, "rank": 2, "delta_24h": 1.8 },
    { "term": "ECB",        "score": 289.4, "rank": 3, "delta_24h": 0.9 }
  ],
  "data_freshness": { "snapshot_age_seconds": 312, "level": "ok" }
}

snapshot_id pins the response to a specific pipeline run — useful for reproducibility. data_freshness tells you how old the underlying data is and whether the pipeline is healthy. Snapshots refresh every few minutes.

Step 4 — What’s the dominant storyline

trending gives you words. narrative gives you the story they form, written by the editorial-grade summarisation pipeline.

curl https://intel-v1.exorde.io/v1/topics/global/narrative \
  -H "X-API-Key: $EXORDE_API_KEY"

import os, httpx

r = httpx.get(
    "https://intel-v1.exorde.io/v1/topics/global/narrative",
    headers={"X-API-Key": os.environ["EXORDE_API_KEY"]},
    timeout=10,
).json()

print(r["summary"])
print()
for sub in r.get("sub_narratives", [])[:3]:
    print(f"  -  {sub['weight']:>5.1%}  {sub['title']}")

The response is structured for both a one-line tile and a deeper drilldown:

{
  "topic": "global",
  "snapshot_id": "2026-05-19T13:00:00Z",
  "summary": "Regional escalation between Iran and Israel dominates global conversation, with overlapping ECB rate signal and Eurovision aftermath as secondary threads.",
  "sub_narratives": [
    { "title": "Iran-Israel exchange",   "weight": 0.61 },
    { "title": "ECB June pivot rumours", "weight": 0.22 },
    { "title": "Eurovision aftermath",   "weight": 0.17 }
  ],
  "data_freshness": { "snapshot_age_seconds": 312, "level": "ok" }
}

Drop summary straight into a Slack tile, a dashboard header, or an email digest — it’s editorial-grade English, not a keyword bag.

Step 5 — Catch the next event with `alerts`

Trending and narrative are the state of the conversation. Alerts are events: keywords whose volume just crossed five sigma above their 14-day baseline, validated by an LLM gate, with severity and spread metadata you can route on.

curl "https://intel-v1.exorde.io/v1/topics/global/alerts?hours=24&limit=10" \
  -H "X-API-Key: $EXORDE_API_KEY"

import os, httpx

r = httpx.get(
    "https://intel-v1.exorde.io/v1/topics/global/alerts",
    params={"hours": 24, "limit": 10, "llm_validated": True},
    headers={"X-API-Key": os.environ["EXORDE_API_KEY"]},
    timeout=10,
).json()

if not r["alerts"]:
    print("Quiet last 24h on global — try hours=168.")
for a in r["alerts"]:
    sev = a["severity"]
    print(f"σ={sev['deviation_sigma']:.2f}  {a['keyword']:<25}  "
          f"{a['spread']['domain_count']}d × {a['spread']['language_count']}l")
    print(f"  {a['description']}\n")

A real alert (cyber topic, paid tier — same envelope on global):

{
  "alert_id": "c80fcfed-6818-44ed-a0b9-0eda91d1401c",
  "detected_at": "2026-05-18T04:00:30.148Z",
  "topic": "cyber",
  "signal_type": "volume_spike",
  "keyword": "dark web",
  "severity":  { "deviation_sigma": 6.67, "current_value": 24.0, "baseline_value": 3.29 },
  "spread":    { "domain_count": 14, "language_count": 8 },
  "llm_validated": true,
  "description": "Multiple credible data breach disclosures (Turkish breach, FoxIT software, gaming accounts) surfacing on dark web with fact-checker verification..."
}

The default hours=168 returns the last week — useful because low-volume topics may emit zero alerts in a 24-hour window. Full envelope, signal types, IOC schema, webhook delivery: Alerts.

What you’ve actually built

Three calls, three different shapes of intelligence, one API key:

Call	Question it answers	Shape
`/trending`	”What words are spiking?”	Ranked list with z-scores
`/narrative`	”What’s the story?”	Editorial summary + sub-narrative weights
`/alerts`	”What just happened?”	Discrete events with severity + spread

That’s the full awareness layer — Watch-tier, available on any trial. The next layer adds investigation (clusters, entities, search, watchlists) and intelligence (editorial reports, custom topics). See Tiers.

Handling the two errors you’ll actually hit

Every non-2xx response is a typed envelope. Match on the error code, never on the prose message. A 16-hex trace_id rides on every response (header X-Exorde-Trace-Id); quote it in support tickets and we resolve in one round trip.

{
  "error": "upgrade_required",
  "message": "This endpoint requires the 'see' tier",
  "feature": "clusters",
  "current_tier": "watch",
  "required_tier": "see",
  "upgrade": true,
  "trace_id": "8b3a47ce91d04f17"
}

The two you’ll hit on a trial:

`error`	When	Fix
`upgrade_required`	You called a See/Know endpoint (clusters, entities, reports, search…)	Stay on Watch endpoints or upgrade
`rate_limited`	More than 30 requests in 60 seconds	Sleep `Retry-After` seconds, then retry

Backoff pattern with header preference:

import time, httpx

def call(url, headers, attempts=5):
    delay = 1
    for _ in range(attempts):
        r = httpx.get(url, headers=headers, timeout=10)
        if r.status_code != 429:
            return r
        wait = int(r.headers.get("Retry-After", delay))
        time.sleep(wait)
        delay = min(delay * 2, 30)
    return r

Full code list and patterns: Errors and Rate limits.

Rotate or revoke if anything leaks

If a key escapes — committed to git, pasted in Slack, screenshotted — kill it immediately. Rotation preserves your tier, topics, expiry; revocation is permanent.

Rotate

curl -X POST https://intel-v1.exorde.io/v1/keys/rotate \
  -H "X-API-Key: $EXORDE_API_KEY"

Revoke

curl -X DELETE https://intel-v1.exorde.io/v1/keys/current \
  -H "X-API-Key: $EXORDE_API_KEY"

Full lifecycle, replay protection, expiry semantics: Authentication.

Where to go next

Alerts in depth

The full alert envelope — signal types, severity math, IOCs, matched clusters, webhooks, dedup.

Use cases

Five copy-paste recipes: newsroom, brand, threat-intel, disinfo, executive dashboard.

Topics & watchlists

Curated topics out of the box; custom watchlists for anything else. Same analytics surface.

Tiers & quotas

Watch / See / Know — what each unlocks, history depth caps, result-size caps.

Authentication

Mint, rotate, revoke, identity, the typed error envelope.

API reference

Every endpoint, live try-it, generated from the OpenAPI spec.

If you get stuck

Status — live per-stream freshness at intel-v1.exorde.io/v1/status. Check this first when something looks slow or empty.
Support — [email protected]. Include the trace_id from the error envelope; we triage faster with it than without.
Changelog — /changelog. What changed, what broke, what’s stable.

Last reviewed: 2026-05-19. API version 1.2.8.

Getting started

Core concepts

Signals

Build

What you’ll be calling

Step 1 — Mint a trial key

Step 2 — Save it once, use it everywhere

Step 4 — What’s the dominant storyline

Step 5 — Catch the next event with `alerts`

What you’ve actually built

Handling the two errors you’ll actually hit

Rotate or revoke if anything leaks

Where to go next

Alerts in depth

Use cases

Topics & watchlists

Tiers & quotas

Authentication

API reference

If you get stuck

​What you’ll be calling

​Step 1 — Mint a trial key

​Step 2 — Save it once, use it everywhere

​Step 3 — What’s trending on global right now

​Step 4 — What’s the dominant storyline

​Step 5 — Catch the next event with alerts

​What you’ve actually built

​Handling the two errors you’ll actually hit

​Rotate or revoke if anything leaks

​Where to go next

Alerts in depth

Use cases

Topics & watchlists

Tiers & quotas

Authentication

API reference

​If you get stuck

What you’ll be calling

Step 1 — Mint a trial key

Step 2 — Save it once, use it everywhere

Step 3 — What’s trending on `global` right now

Step 4 — What’s the dominant storyline

Step 5 — Catch the next event with `alerts`

What you’ve actually built

Handling the two errors you’ll actually hit

Rotate or revoke if anything leaks

Where to go next

If you get stuck