# Cloud Outage Feed: AWS, Azure, GCP, M365 & Cloudflare Alerts (`cobalt_relay/cloud-outage-feed`) Actor

One feed of live incidents from AWS, Azure, Google Cloud, Cloudflare and your Microsoft 365 tenant, filtered to your regions and services, with Slack and Teams alerts when something changes.

- **URL**: https://apify.com/cobalt_relay/cloud-outage-feed.md
- **Developed by:** [Cobalt Relay](https://apify.com/cobalt_relay) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 status checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Cloud Outage Feed: AWS, Azure, Google Cloud, Microsoft 365 & Cloudflare Status Alerts

One feed for the clouds you depend on. This Actor checks the official status sources of **AWS, Microsoft Azure, Google Cloud and Cloudflare**, plus **your own Microsoft 365 tenant** and any other Statuspage-based service, filters them to **the regions and services you actually use**, and alerts **Slack or Microsoft Teams** when something starts, changes or is resolved.

Schedule it every 15 minutes or hourly and you get a quiet channel that only speaks up when it matters.

### What you get

```
🟠 Updated · Google Cloud · Cloud SQL connectivity issues in Montreal (northamerica-northeast1)
✅ Resolved · AWS · Amazon EC2: Increased API Error Rates (ca-central-1)
🔴 New · Cloudflare · Elevated latency in Toronto (Toronto, ON, Canada - (YYZ))
```

Every incident is also saved as a row you can export (CSV, Excel, JSON) or pull through the API:

| Field | Meaning |
|---|---|
| `changeType` | `new`, `updated`, `resolved` (or `unchanged` when "Only report changes" is off) |
| `provider` | `aws`, `azure`, `gcp`, `cloudflare`, `m365`, or `statuspage:<host>` |
| `status` | `active` or `resolved` |
| `severity` | `info`, `degraded`, `outage` or `unknown` |
| `title` | Incident headline |
| `services` | Affected services |
| `regions` | Affected regions or locations (`global` if worldwide) |
| `startedAt`, `updatedAt`, `resolvedAt` | Times in UTC |
| `latestUpdate` | Text of the most recent provider update |
| `url` | Link to the incident on the provider's status page |

### Why use it

- **Filtered to you.** Watch `ca-central-1`, `canadacentral` and `northamerica-northeast1` instead of reading about every region on Earth.
- **Only changes.** Scheduled runs report what's new, updated or resolved since the last run, so alerts don't repeat.
- **No flood on day one.** The first run of a new schedule quietly records what's already ongoing; alerts start from the next change.
- **Your Microsoft 365 tenant, not just the public page.** Connect an app registration to include the incidents and advisories Microsoft shows in *your* admin center.
- **Add the rest of your stack.** GitHub, Atlassian, Okta, Datadog and thousands of other services publish on Statuspage; paste their URLs to include them.

### Sources

| Provider | Source | Notes |
|---|---|---|
| AWS | Public AWS Health Dashboard feed | Region-level events for all AWS services. Account-specific events need the AWS Health API and aren't included. |
| Google Cloud | Google Cloud Service Health (`incidents.json`) | Products and locations use Google's stable IDs, e.g. `northamerica-northeast1`. |
| Azure | Public Azure status RSS | **Microsoft only posts broad, multi-region incidents here.** Most Azure issues are sent privately through Azure Service Health in your portal, so this feed is usually empty, and that's normal. |
| Cloudflare | Cloudflare status (Statuspage) | Data centers are listed as locations, e.g. `Toronto, ON, Canada - (YYZ)`. |
| Microsoft 365 | Microsoft Graph service health, **your tenant** | Optional; see below. |
| Others | Any Statuspage-based page | Optional; add URLs in "Other Statuspage-based status pages". |

### How to use it

1. Pick the **status sources** to check.
2. Optionally list **regions** (codes or place names, matched loosely) and **services** (keywords like `EC2`, `Cloud SQL`, `Exchange`).
3. Add a **Slack** or **Teams** webhook URL, or a generic webhook for your own system.
4. Save it as a **task** and **schedule** it, e.g. every 15 minutes.

Each task keeps its own memory of what it has already reported, so you can run separate schedules for separate clients or teams.

#### Slack setup

Create an [incoming webhook](https://api.slack.com/messaging/webhooks) for the channel and paste its URL.

#### Microsoft Teams setup

In the channel, open **Workflows** and use the template **"Post to a channel when a webhook request is received"**. Paste the URL it gives you. (Classic Office 365 connectors are being retired; Workflows is Microsoft's replacement.)

#### Connect your Microsoft 365 tenant (optional)

1. In the Entra admin center, create an **App registration**.
2. Under **API permissions**, add **Microsoft Graph → Application permissions → ServiceHealth.Read.All**, then **Grant admin consent**.
3. Under **Certificates & secrets**, create a client secret.
4. Enter the **tenant ID**, **application (client) ID** and **client secret** in the Actor input. The secret is stored encrypted.

The permission is read-only and covers service health only. It gives no access to mail, files or users.

### Pricing

- **$0.003 per status check** (one run, all sources).
- **$0.01 per incident reported.**

With "Only report changes" on, quiet runs cost only the check. An hourly schedule costs about **$2.20 a month** plus a cent per incident change; every 15 minutes, about $8.70 a month.

### FAQ

**Why is Azure always empty?**
By design. Microsoft reserves the public status page for incidents with broad, multi-region impact and notifies everyone else privately through Azure Service Health. When Azure has a big outage, it will show up here.

**Can it read AWS events for my own account?**
Not yet. Account-specific AWS events come from the AWS Health API, which needs your AWS credentials (and a Business support plan or higher).

**How do region filters match?**
Loosely and case-insensitively, against each incident's region codes and location names, with the incident title and text as a fallback. `northamerica-northeast` matches both Montreal and Toronto GCP regions; `Toronto` matches Cloudflare's YYZ data center. Global incidents are included unless you turn off "Include global incidents".

**One source failed; did I lose everything?**
No. Each source is fetched independently. If one can't be reached, the run still reports the others and says which one failed.

### Feedback

Want another provider or alert channel? Open an issue on this Actor's **Issues** tab.

# Actor input Schema

## `providers` (type: `array`):

Which public status feeds to check.

## `regions` (type: `array`):

Optional. Region codes or place names, matched loosely, e.g. ca-central-1, canadacentral, northamerica-northeast, Toronto, us-east. Leave empty to watch everywhere.

## `includeGlobal` (type: `boolean`):

Keep incidents that affect all regions (or don't name one) even when a region filter is set.

## `services` (type: `array`):

Optional. Service name keywords, e.g. EC2, S3, Compute Engine, Exchange Online, Teams. Leave empty for all services.

## `minSeverity` (type: `string`):

Skip anything below this level.

## `lookbackHours` (type: `integer`):

Include incidents updated or resolved within this many hours. Ongoing incidents are always included.

## `includeResolved` (type: `boolean`):

Report incidents resolved within the look-back window (useful for 'all clear' alerts).

## `onlyChanges` (type: `boolean`):

For scheduled runs: output only incidents that are new, updated or resolved since the previous run of this task. Turn off to get the full current list every time.

## `slackWebhookUrl` (type: `string`):

Optional. Posts changed incidents to a Slack channel.

## `teamsWebhookUrl` (type: `string`):

Optional. URL from a Teams 'Post to a channel when a webhook request is received' workflow.

## `webhookUrl` (type: `string`):

Optional. Receives a JSON POST {"incidents": \[...]} with the changed incidents.

## `alertOnFirstRun` (type: `boolean`):

By default the first run of a new schedule only records what's already ongoing, so your channel isn't flooded. Turn on to alert on everything immediately.

## `m365TenantId` (type: `string`):

Optional. Adds your own tenant's Microsoft 365 incidents and advisories (from Microsoft Graph). Needs an Entra ID app with the ServiceHealth.Read.All application permission.

## `m365ClientId` (type: `string`):

Application (client) ID of the Entra ID app registration.

## `m365ClientSecret` (type: `string`):

Client secret value of the app registration. Stored encrypted.

## `statuspageUrls` (type: `array`):

Optional. Add any status page built on Atlassian Statuspage, e.g. https://www.githubstatus.com, https://status.atlassian.com.

## Actor input object example

```json
{
  "providers": [
    "aws",
    "azure",
    "gcp",
    "cloudflare"
  ],
  "regions": [
    "ca-central-1",
    "canadacentral",
    "canadaeast",
    "northamerica-northeast",
    "Toronto",
    "Montreal"
  ],
  "includeGlobal": true,
  "minSeverity": "info",
  "lookbackHours": 24,
  "includeResolved": true,
  "onlyChanges": true,
  "alertOnFirstRun": false
}
```

# Actor output Schema

## `incidents` (type: `string`):

Incidents from AWS, Azure, Google Cloud, Cloudflare and Microsoft 365 matching your filters, with status, severity, regions, services and a link to the provider's status page.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "regions": [
        "ca-central-1",
        "canadacentral",
        "canadaeast",
        "northamerica-northeast",
        "Toronto",
        "Montreal"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cobalt_relay/cloud-outage-feed").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "regions": [
        "ca-central-1",
        "canadacentral",
        "canadaeast",
        "northamerica-northeast",
        "Toronto",
        "Montreal",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cobalt_relay/cloud-outage-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "regions": [
    "ca-central-1",
    "canadacentral",
    "canadaeast",
    "northamerica-northeast",
    "Toronto",
    "Montreal"
  ]
}' |
apify call cobalt_relay/cloud-outage-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cobalt_relay/cloud-outage-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cKfAadag9TYMBCQMl/builds/28aGZ2bruBOndu8la/openapi.json