Airspace risk, as a field
in your JSON.
One authenticated GET returns a 0–100 risk index with level, confidence and explicit coverage for any route — ~50ms, no PII, 334 FIRs scored daily. Wire it into a dispatch board, a search result, a policy engine; let webhooks push threshold events back.
A data layer, not a verdict: your system reads the field, your logic makes the call.
The sandbox key is free — 50 requests/day on a deterministic sample dataset, no card. Production starts at $2,000/month when you ship. Compare tiers →
The response, field by field.
The sellable unit is this JSON — the exact v2 contract your systems consume.
/route/risk?from=DXB&to=DEL&via=MCT {
"from": "DXB", "to": "DEL", "via": ["MCT"],
"date": "2026-07-14",
"score": 41, "risk_level": "moderate",
"confidence": 0.82,
"legs": [
{ "from": "DXB", "to": "MCT", "score": 31 },
{ "from": "MCT", "to": "DEL", "score": 41 }
],
"coverage": { "status": "covered", … },
"scored_at": 1783641600
} Two fields carry most integrations: a number to sort, gate and alert on; a band to colour and display. No parsing, no prose.
Multi-leg trips score per segment, and no score travels without its confidence — weight it, discount it, or surface it.
Unknowns are explicit: status: "out_of_scope", score null. Your logic branches cleanly instead of inheriting false calm.
Illustrative values — the field shape is the exact v2 contract. Scores refresh every 5–30 minutes; always branch on coverage.status, never treat null as 0. Full contract: API docs.
Integration is an afternoon.
Get a key
Sandbox key in minutes — no card, no call. 50 requests/day on a deterministic sample dataset, official SDKs on npm and PyPI, docs with copy-paste examples.
Make one GET
GET /route/risk?from=…&to=… — no request body, no PII, ~50ms from cache. Read score and risk_level; branch on coverage.status. Add via= for multi-leg and date= for departures up to 30 days out.
Let it push
On Pro, set index thresholds per FIR or route — a structured event posts to your webhook when one is crossed. Your board updates without polling.
Official SDKs — two lines to your first scored route.
MIT-licensed clients on the public registries, smoke-tested against the live API on every release. Both cover route risk on engine v1/v2 (incl. reroute analysis), self-serve introspection, webhook management and signature verification — retries with backoff built in.
npm install @flysafe/api import { Client } from '@flysafe/api';
const fs = new Client({ apiKey: KEY });
const r = await fs.routeRisk('LHR', 'DXB');
// r.score → 54 · r.risk_level → 'high' Zero dependencies · TypeScript types · Node 18+, browsers, Workers, Deno
pip install flysafe-api from flysafe import Client
fs = Client(api_key=KEY)
r = fs.route_risk("LHR", "DXB")
# r["score"] → 54 · r["risk_level"] → 'high' Python 3.8+ · single dependency (requests) · sync client, ~200 lines
Current release 0.2.x — semver applies: anything breaking lands behind a major bump, announced in the public changelog.
Four tiers, one contract.
- → 334 FIRs scored daily from public regulatory & operational data — EASA · FAA · ICAO · ADS-B · conflict-event signals
- → Published methodology; versioned scores, validated against an event ground truth
- → Per-key audit log for compliance reviews
- × A verdict. The index is an input; your system's logic — and your users — make the call.
- × Uniform depth everywhere. Four coverage tiers; every score states its confidence and coverage.
- × A NOTAM replacement. Official sources stay authoritative — the feed says where to look first.
Where it plugs in.
Your role page shows the integration against your workflow — with a live widget to try.
Early-warning column on the dispatch board + threshold webhooks
Risk badge on results, checkout notices, agent gating
Network exposure feeds with history and source flags
Booking-time lookups wired into policy rules
How to start.
Integrate on the free key — pay only when you ship to production.
- 1
Get the sandbox key — takes minutes. No card, no sales call.
- 2
Build against a stable sample dataset — 50 requests/day free is enough to integrate, test, and demo to your team; production keys switch you to live data.
- 3
Upgrade when you ship: Starter $2K/mo (300K req, full horizons, multi-leg) → Pro $5K/mo (webhooks, 99.9% SLA) → Enterprise (white-label, custom). Annual saves two months.
The same engine runs as the Console — check routes in the browser, keep dated, verifiable basis-of-decision records. From $99/month, 14-day free trial, no card.
API — FAQ
Common search queries answered with current status, FIR codes, and source citations.
- Are there official SDKs?
- Yes —
@flysafe/apion npm (zero-dependency, TypeScript types, Node 18+/browsers/Workers) andflysafe-apion PyPI (Python 3.8+). Both cover route risk, engine v1/v2, retries with backoff and webhook signature verification. MIT-licensed. - How fast is it, really?
- ~50ms from cache for covered routes — it sits in a results render path without meaningful latency. Scores recompute every 5–30 minutes across 334 daily-scored FIRs;
scored_atships in every response so your cache invalidates correctly. - Do requests carry personal data?
- No. A request is airport codes and an optional date — no passenger data, no identifiers, no cookies. GDPR-neutral by design; a DPA is available on request for paid tiers.
- What happens outside your coverage?
- The response says so:
coverage.status = "out_of_scope"withscore: nullandrisk_level: "unknown"— never a guessed number. Always branch on the coverage object; treatingnullas 0 is the one integration mistake the docs warn about twice. - How accurate are the scores?
- They are versioned numerical indices, not certainties: every score carries
scoring_versionandconfidence, historical scores are never rewritten, and every scoring change is validated against a documented event ground truth before release. The methodology is documented so your team can validate against its own data before anything ships to users. - What separates Sandbox from production?
- Sandbox is a development environment: deterministic test data with the FULL response schema (including /detailed and /firs) and documented test cases — the same route always returns the same score, so your tests never flake. Production keys serve live scores with full horizons (7d/30d), volume, webhooks (Pro) and SLA. Want to SEE live scores before buying? That is the Console trial — 14 days, no card. Integrate on Sandbox, evaluate in Console, upgrade when you ship.
- Can we white-label it?
- On Enterprise — unlimited volume, custom SLA (99.95%+), dedicated infrastructure, custom FIR coverage, NDA + DPA, and the extended
/route/risk/detailedendpoint with per-FIR breakdown and data-quality metrics. Talk to us. - When is the Console the better fit?
- When people, not systems, consume the scores — and when you need dated, verifiable records of decisions rather than a data feed. The Console product page covers it; many teams run both.
FlySafe provides automated computation of numerical indices from publicly available data. Indices are raw computational output and do not represent opinions, assessments, recommendations, or advice of any kind. They do not replace official NOTAMs, SIGMETs, AIPs, or communications from aviation authorities. See Terms of Service.