# Vendor Status Intelligence API (`refreshing_pail/vendor-status-intelligence`) Actor

Normalize public SaaS and cloud status pages into current health, component outages, incident history, and audit-ready reliability records.

- **URL**: https://apify.com/refreshing\_pail/vendor-status-intelligence.md
- **Developed by:** [Michael](https://apify.com/refreshing_pail) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 vendor status audits

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Vendor Status Intelligence API do?

**Vendor Status Intelligence API turns public SaaS and cloud status pages into one consistent dataset.** Add status-page URLs for vendors such as [OpenAI](https://status.openai.com/), [GitHub](https://www.githubstatus.com/), or [Slack](https://status.slack.com/), and the Actor returns current health, affected components, active incidents, recent incident history, and incident-window metrics.

The Actor runs on the Apify platform, so the same workflow can be called through an API, scheduled, monitored, connected to webhooks, or exported to common data formats. It supports Atlassian Statuspage-compatible JSON endpoints, Slack’s public Status API, RSS or Atom incident feeds, and a best-effort HTML fallback.

### Why use Vendor Status Intelligence API?

Modern teams depend on many outside services, but every vendor publishes status differently. Opening ten tabs during an incident is slow, and copying incident timelines into vendor reviews or audit evidence is tedious.

Use this Actor to:

- Build a single health dashboard for a SaaS or cloud stack.
- Feed vendor incidents into Slack, email, Jira, Make, Zapier, or an internal workflow.
- Compare publicly reported incident frequency and duration during procurement or renewal reviews.
- Retain repeatable evidence for vendor-risk, business-continuity, SOC 2, or ISO 27001 processes.
- Give support and operations teams a fast way to determine whether a dependency is reporting an outage.

The output is deliberately evidence-based. `incidentFreePercent` measures time without a **publicly reported incident interval** in the selected window. It is not an independent uptime test, an SLA measurement, or a guarantee that the vendor reported every problem.

### How to use Vendor Status Intelligence API

1. Open the Actor in Apify Console.
2. Add one or more public vendor status-page URLs.
3. Choose an incident-history window, such as 30 or 90 days.
4. Decide whether scheduled maintenance should count in the history.
5. Click **Start**.
6. Review the overview table or download the complete dataset.
7. For ongoing monitoring, create an Apify Schedule and attach the integration or webhook you prefer.

The Actor also supports Standby mode. Send the same JSON input to `POST /audit` on the Actor’s Standby hostname for a synchronous JSON response.

The Standby tab includes an interactive API specification, request example, and response schema.

### Input

The Input tab contains all supported options. A typical request is:

```json
{
    "statusPageUrls": [
        "https://status.openai.com",
        "https://www.githubstatus.com",
        "https://status.slack.com"
    ],
    "sinceDays": 90,
    "maxIncidentsPerVendor": 50,
    "includeMaintenances": false,
    "maxConcurrency": 5,
    "requestTimeoutSeconds": 20,
    "failOnError": false
}
```

Each run accepts up to 100 unique public status-page URLs. Private, local, and reserved network targets are rejected.

### Supported status pages

The Actor has first-class support for Atlassian Statuspage-compatible public APIs and Slack Status, plus RSS/Atom incident feeds and a best-effort HTML fallback. A live compatibility check across 25 well-known vendors produced 19 full structured results, 6 caller-visible partial results, and no failed collections.

Full structured coverage included OpenAI, GitHub, Slack, Cloudflare, Discord, Atlassian, Twilio, Zoom, Datadog, Reddit, Dropbox, Vercel, Figma, Canva, Supabase, Netlify, Sentry, MongoDB, and Notion. See [the provider coverage report](PROVIDER_COVERAGE.md) for the dated matrix and interpretation.

### Output

Every submitted URL produces one top-level dataset item, including failed requests:

```json
{
    "requestUrl": "https://www.githubstatus.com/",
    "provider": "atlassian-statuspage",
    "vendorName": "GitHub",
    "collectionStatus": "success",
    "currentIndicator": "operational",
    "needsAttention": false,
    "activeIncidentsCount": 0,
    "incidentsInWindow": 8,
    "reportedIncidentMinutes": 214,
    "incidentFreePercent": 99.8349,
    "recentIncidents": [
        {
            "id": "incident-123",
            "title": "Degraded performance",
            "status": "resolved",
            "impact": "minor",
            "url": "https://www.githubstatus.com/incidents/example",
            "startedAt": "2026-07-20T10:00:00.000Z",
            "resolvedAt": "2026-07-20T10:45:00.000Z",
            "durationMinutes": 45,
            "affectedComponents": ["API Requests"],
            "latestUpdate": "This incident has been resolved.",
            "isMaintenance": false
        }
    ],
    "collectedAt": "2026-07-28T15:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field                     | Description                                                                           |
| ------------------------- | ------------------------------------------------------------------------------------- |
| `provider`                | Detected status-page implementation                                                   |
| `currentIndicator`        | Normalized operational, degraded, outage, maintenance, or unknown state               |
| `needsAttention`          | Quick flag for non-operational states, active incidents, or partial/failed collection |
| `components`              | Public service components and their reported states                                   |
| `activeIncidents`         | Currently unresolved public incidents                                                 |
| `recentIncidents`         | Incidents overlapping the selected history window                                     |
| `reportedIncidentMinutes` | Union of known public incident intervals, without double-counting overlaps            |
| `incidentFreePercent`     | Percentage of the window with no known public incident interval                       |
| `sourceEndpoints`         | Public URLs used as evidence for the record                                           |
| `error`                   | Explanation when collection is partial or failed                                      |

### How much does it cost to monitor vendor status pages?

This Actor uses lightweight public HTTP requests and does not launch a browser, so compute usage should remain low for ordinary watchlists. Actual cost depends on the number of vendors, history depth exposed by each provider, run frequency, memory setting, and your Apify plan.

Start with a small watchlist and inspect the run’s platform-usage statistics before creating a frequent schedule. A daily run is usually enough for governance reporting; operational alerting may justify a shorter interval. Apify’s free platform credits, when included in your current plan, can be used for trial runs.

### Advanced options

- Use a shorter `sinceDays` value for lightweight daily digests.
- Enable `includeMaintenances` when planned work matters to business-continuity reporting.
- Set `failOnError` to `false` for resilient batch jobs that must always return one record per vendor.
- Use `sourceEndpoints` to preserve provenance in downstream reports.
- Treat vendor-reported status as one signal. For critical dependencies, combine it with synthetic monitoring of the actual workflow your application depends on.
- If a page only produces a `partial` result, submit its direct public status-page URL rather than a corporate support or documentation page.

### FAQ, disclaimers, and support

**Does this independently test vendor uptime?** No. It normalizes what vendors publish on their public status pages. Pair it with synthetic or application-level monitoring when independent verification is required.

**Why is incident-free percentage null?** Some feeds publish incident messages without both start and resolution timestamps. The Actor avoids inventing durations.

**Does it access private customer status pages?** No. The Actor does not log in, bypass access controls, or access private networks.

**Is public status-page collection legal?** Public operational notices are generally published for customers to read and subscribe to, but you remain responsible for applicable terms, laws, retention rules, and downstream use.

If a public provider format is not recognized or changes, use the Actor’s **Issues** tab and include the public status-page URL. Custom provider adapters and larger vendor-intelligence workflows are also available as custom solutions.

# Actor input Schema

## `statusPageUrls` (type: `array`):

Public status pages to analyze. Supports Atlassian Statuspage-compatible sites, Slack Status, and RSS/Atom-backed status pages.

## `sinceDays` (type: `integer`):

Include incidents that overlap this many days before the run. Public providers may expose less history.

## `maxIncidentsPerVendor` (type: `integer`):

Maximum recent incidents included in each vendor record.

## `includeMaintenances` (type: `boolean`):

Include scheduled maintenance events in the recent incident history and summary metrics.

## `maxConcurrency` (type: `integer`):

Number of vendor status pages processed at once.

## `requestTimeoutSeconds` (type: `integer`):

Maximum time allowed for each public status endpoint request.

## `failOnError` (type: `boolean`):

When disabled, unreachable or unsupported pages produce structured failure records while the remaining vendors continue.

## Actor input object example

```json
{
  "statusPageUrls": [
    "https://status.openai.com",
    "https://www.githubstatus.com",
    "https://status.slack.com"
  ],
  "sinceDays": 90,
  "maxIncidentsPerVendor": 50,
  "includeMaintenances": false,
  "maxConcurrency": 5,
  "requestTimeoutSeconds": 20,
  "failOnError": false
}
```

# Actor output Schema

## `results` (type: `string`):

Full machine-readable records with current health, metrics, and incident history.

## `overview` (type: `string`):

Compact table of current status, public incident-duration indicators, and collection status.

# 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 = {
    "statusPageUrls": [
        "https://status.openai.com",
        "https://www.githubstatus.com",
        "https://status.slack.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("refreshing_pail/vendor-status-intelligence").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 = { "statusPageUrls": [
        "https://status.openai.com",
        "https://www.githubstatus.com",
        "https://status.slack.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("refreshing_pail/vendor-status-intelligence").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "statusPageUrls": [
    "https://status.openai.com",
    "https://www.githubstatus.com",
    "https://status.slack.com"
  ]
}' |
apify call refreshing_pail/vendor-status-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=refreshing_pail/vendor-status-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/3cYyIbFKp7qhlhXdm/builds/FQjigLJEda8tvmPRj/openapi.json