Forecasts
A forecast says what comparable past events did to travel: how often they led to website outages, check-in problems or cancellations, with an 80% interval and n, the number of events behind each number. Analog forecasts exist for IT outages today; other signal types get recommended actions and airport base rates.
Where do forecasts appear?#
GET /v1/signals/{id}includesimpact_forecastfor any signal.GET /v1/forecast?provider=...&failure_layer=...is a what-if: the forecast for an outage that has not happened.failure_layeris required;GET /v1/failure-layerslists the values.- Exposure matches on IT outages carry a short
forecast: the top four outcomes, recommended actions and expected duration. - Webhook payloads for IT outage signals include
impact_forecast.
curl "https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns" \
-H "Authorization: Bearer $DISRUPT_KEY"// Node.js 18+ (built-in fetch), saved as an .mjs file
const res = await fetch("https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns", {
method: "GET",
headers: {
Authorization: `Bearer ${process.env.DISRUPT_KEY}`,
},
signal: AbortSignal.timeout(30_000),
});
const json = await res.json();
if (!res.ok) {
throw new Error(`${res.status} ${json.error.code}: ${json.error.message}`);
}
console.log(JSON.stringify(json.data, null, 2));import os
import requests
resp = requests.get(
"https://app.disruptapi.com/v1/forecast",
headers={"Authorization": f"Bearer {os.environ['DISRUPT_KEY']}"},
params={"provider": "cloudflare", "failure_layer": "edge_cdn_dns"},
timeout=30,
)
if not resp.ok:
err = resp.json()["error"]
raise SystemExit(f"{resp.status_code} {err['code']}: {err['message']}")
print(resp.json()["data"])import os
import httpx
with httpx.Client(
base_url="https://app.disruptapi.com",
headers={"Authorization": f"Bearer {os.environ['DISRUPT_KEY']}"},
timeout=30,
) as client:
resp = client.get(
"/v1/forecast",
params={"provider": "cloudflare", "failure_layer": "edge_cdn_dns"},
)
if resp.is_error:
err = resp.json()["error"]
raise SystemExit(f"{resp.status_code} {err['code']}: {err['message']}")
print(resp.json()["data"])package main
import (
"fmt"
"io"
"log"
"net/http"
"os"
"time"
)
func main() {
req, err := http.NewRequest(http.MethodGet, "https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns", nil)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", "Bearer "+os.Getenv("DISRUPT_KEY"))
client := &http.Client{Timeout: 30 * time.Second}
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
out, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(resp.StatusCode, string(out))
}require "json"
require "net/http"
require "uri"
uri = URI("https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV.fetch("DISRUPT_KEY")}"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30) do |http|
http.request(req)
end
json = JSON.parse(res.body)
abort "#{res.code} #{json["error"]["code"]}: #{json["error"]["message"]}" unless res.is_a?(Net::HTTPSuccess)
puts JSON.pretty_generate(json["data"])<?php
$ch = curl_init("https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns");
curl_setopt_array($ch, [
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTPHEADER => [
"Authorization: Bearer " . getenv("DISRUPT_KEY"),
],
]);
$raw = curl_exec($ch);
if ($raw === false) {
exit("request failed: " . curl_error($ch) . PHP_EOL);
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
curl_close($ch);
$json = json_decode($raw, true);
if ($status >= 400) {
exit("{$status} {$json['error']['code']}: {$json['error']['message']}" . PHP_EOL);
}
print_r($json["data"]);// Java 17+. Run with: java Main.java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
public class Main {
public static void main(String[] args) throws Exception {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns"))
.timeout(Duration.ofSeconds(30))
.header("Authorization", "Bearer " + System.getenv("DISRUPT_KEY"))
.GET()
.build();
HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());
}
}// .NET 7+ console app (top-level statements, C# 11 raw strings)
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("DISRUPT_KEY"));
using var response = await http.GetAsync("https://app.disruptapi.com/v1/forecast?provider=cloudflare&failure_layer=edge_cdn_dns");
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());{
"data": {
"basis": "analogs",
"failure_layer": "edge_cdn_dns",
"failure_layer_label": "Edge, CDN and DNS",
"analog_count": 14,
"analogs": [
{
"id": "2025-11-cloudflare",
"title": "Cloudflare outage (bot management file exceeded size limit)",
"provider": "cloudflare",
"failure_layer": "edge_cdn_dns",
"starts_at": "2025-11-18T11:20:00Z",
"duration_h": null,
"outcomes": { "website_or_app_down": 1 },
"url": null
}
],
"outcomes": [
{
"outcome": "website_or_app_down",
"label": "Airline websites or apps down",
"probability": 0.778,
"interval": [0.594, 0.931],
"interval_level": 0.8,
"k": 6,
"n": 7,
"analog_level": "same failure layer, any provider",
"low_confidence": false,
"evidence": "6 of 7 analogs (documented); e.g. Cloudflare outage (bot management file exceeded size limit)",
"base_rate": null,
"lift": null,
"above_base_rate": null
},
{
"outcome": "carrier_cancellation_spike",
"label": "A US carrier's own cancellations jump (BTS, carrier-caused)",
"probability": 0.312,
"interval": [0.172, 0.464],
"interval_level": 0.8,
"k": 4,
"n": 14,
"analog_level": "broader group of IT outages",
"low_confidence": false,
"evidence": "4 of 14 analogs (bts); ordinary days show this 21% of the time, so these events do not clearly raise it",
"base_rate": { "probability": 0.21, "windows": 56 },
"lift": 0.102,
"above_base_rate": false
}
],
"expected_duration_hours": {
"p50": 2.4,
"p90": 7.9,
"n": 11,
"analog_level": "same failure layer, any provider"
},
"carriers_at_elevated_risk": [
{
"carrier": "AS",
"confidence": "medium",
"reasons": [
"alaskaair.com uses cloudflare (edge_cdn)",
"alaskaair.com uses cloudflare (dns)"
],
"dependency_layers": ["dns", "edge_cdn"],
"past_events": 0
}
],
"contrast": "Different failure layer from CrowdStrike (July 2024), where an endpoint agent crashed Windows machines at airlines and airports and Delta cancelled about 7,000 flights. A edge, cdn and dns failure usually leaves those machines running.",
"recommended_actions": [
"Airline and booking websites may fail; check in at the airport or by app if the web is down",
"Allow extra time at airports for groups that cannot check in online"
],
"notes": [
"Probabilities use a Beta-binomial model with a uniform prior; n is the number of past events where the outcome was measured or documented. Treat any outcome marked low_confidence (n under 5) as indicative."
]
}
}Which outcomes are forecast?#
| Outcome | Meaning |
|---|---|
website_or_app_down | Airline websites or apps down |
checkin_disrupted | Check-in disrupted |
any_cancellations | Flight cancellations at one or more carriers |
carrier_cancellation_spike | A US carrier's own cancellations jump (BTS, carrier-caused) |
us_cancellation_spike | US-wide carrier-caused cancellations double |
ground_stops_above_normal | FAA ground stops well above normal |
passenger_comms_disrupted | Passenger notifications (email, SMS) delayed or failing |
Outcomes with no history for the provider and layer are left out rather than guessed.
How are analogs chosen?#
For each outcome separately, DisruptAPI looks for past events in the catalogue (GET /v1/events) at the most specific level that has at least 5 events where that outcome was measured or documented:
- Same provider and failure layer, e.g. Cloudflare edge failures.
- Same failure layer, any provider, e.g. every edge, CDN and DNS failure.
- Broader group: all IT outages that matter for travel, or all cloud outages for the cloud layers. At this level only measured outcomes (BTS and FAA data) are pooled, because documented outcomes come from notable events that lean towards severe cases.
If no level reaches 5, the level with the most cases is used and the outcome is marked low_confidence. analog_level says which level was used.
How is the probability calculated?#
A Beta-binomial model with a uniform prior. With k of n analogs showing the outcome, the probability is (k + 1) / (n + 2) and the interval is the central 80% of the Beta(k + 1, n − k + 1) distribution. Two of nine gives 0.273 with an interval of 0.116 to 0.45. The interval is wide when n is small, on purpose.
What are base rates and lift?#
Some outcomes happen on ordinary days too. US carrier-caused cancellation spikes, for example, show up on roughly one ordinary day in five. For measured outcomes, DisruptAPI checks the same outcome on matched control windows of the same length with no catalogued event, and reports:
base_rate.probability: the share of control windows with the outcome, andbase_rate.windows, how many were checked.lift: the forecast probability minus the base rate.above_base_rate: true only when the whole 80% interval sits above the base rate. That is the test for "this kind of event makes the outcome more likely".
Documented outcomes (from reports about notable events) have no control windows, so their base rate fields are null.
How should I read a forecast?#
- Lead with outcomes where
above_base_rateis true. They are listed first. An outcome withabove_base_rate: falsehappens about as often without the event; its evidence text says so. - Always show
n, and say "indicative" whenlow_confidenceis true. - Read the interval, not only the point. 0.78 with an interval of 0.59 to 0.93 from 7 events is a strong signal; 0.40 from 3 events is not.
- Use
carriers_at_elevated_riskto decide which airlines to watch.highneeds both a dependency and a past impact; dependencies alone givelowormedium.
Outcome fields#
| Field | Type | Description |
|---|---|---|
outcome | string | Outcome id, from the table above. |
label | string | What the outcome means, in words. |
probability | number | Posterior mean, 0 to 1: (k + 1) / (n + 2). |
interval | [number, number] | Central 80% credible interval. |
interval_level | number | Always 0.8. |
k | integer | Past events where the outcome happened. |
n | integer | Past events where the outcome was measured or documented. The sample size; always report it. |
analog_level | string | Which group of past events was used: "same provider and failure layer", "same failure layer, any provider" or "broader group of IT outages". |
low_confidence | boolean | True when n is under 5. |
evidence | string | Plain-words summary: "2 of 9 analogs (bts, documented); e.g. ...", and a note when ordinary days show the outcome as often. |
base_rate | object | null | {probability, windows}: how often the outcome happens in matched ordinary windows with no catalogued event. Null for documented-only outcomes. |
lift | number | null | probability minus base_rate.probability. Null without a base rate. |
above_base_rate | boolean | null | True only when the whole interval is above the base rate. Null without a base rate. |
Forecast fields#
| Field | Type | Description |
|---|---|---|
basis | string | analogs for IT outages; insufficient_history for other signal types. |
failure_layer | string | null | The layer the forecast is for. |
failure_layer_label | string | null | Its label. |
analog_count | integer | Distinct past events used across all outcomes and the duration estimate. |
analogs | object[] | Up to 6 named comparable events: id, title, provider, failure_layer, starts_at, duration_h, outcomes (outcome id to 0 or 1), url. Landmark events first. |
outcomes | object[] | One entry per outcome with any history, fields below. Outcomes that do not beat their base rate are listed last. |
expected_duration_hours | object | null | p50, p90, n and analog_level from past durations. Null when none are known. |
carriers_at_elevated_risk | object[] | Up to 25 airlines: carrier, confidence (low, medium, high), reasons, dependency_layers, past_events. |
contrast | string | null | How this layer differs from an endpoint crash like CrowdStrike in July 2024. |
recommended_actions | string[] | Practical steps for this failure layer or signal type. |
notes | string[] | Method notes to show next to the numbers. |
airport_base_rates | object | Non-IT signals with airports: per airport, that month's cancellation and delay base rates where measured (US airports). |
What are the caveats?#
- US-centred measurements. BTS cancellation outcomes cover US carriers only. Outside the US, outcomes come from documented reports, and history is thin.
- Non-IT signals have no analogs yet. Weather, hazards, advisories and others return
basis: "insufficient_history"with recommended actions, plus monthly airport base rates (airport_base_rates) where they exist, which is at US airports. - Selection bias in documented events. Famous outages are better documented than small ones. They only count within the same failure layer.
- The catalogue grows. Numbers change as new events and outcomes are added. Do not cache a forecast for long, and do not compare numbers across months as if the method were fixed.
Last updated 2026-11-18. Questions or a mistake on this page? Contact us.