# AI Tool Uptime Leaderboard (`ianymu/ai-tool-uptime-leaderboard`) Actor

Compute uptime % over the past N days for each AI provider (Anthropic, OpenAI, Google AI, Mistral, Cohere, ...) using their public status pages. Outputs a ranked uptime leaderboard with incident count and per-component downtime breakdown.

- **URL**: https://apify.com/ianymu/ai-tool-uptime-leaderboard.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## AI Tool Uptime Leaderboard

Compute **uptime %** over the past N days for each major AI provider (Anthropic, OpenAI, Google AI, Mistral, Cohere, ...) by pulling **incident history** directly from their public status pages. Outputs a ranked leaderboard with incident counts, major/minor breakdown, and per-component downtime - everything you need to compare reliability across AI vendors at a glance.

Part of Ian Mu's 100-actor portfolio at [github.com/ianymu](https://github.com/ianymu). Inspired by the post-Stop self-verification flow at [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop).

### What does AI Tool Uptime Leaderboard do?

Given a list of providers and a time window (default 30 days), the Actor fetches each provider's status-page incident history. For Atlassian Statuspage-powered sites (most AI providers including Anthropic, OpenAI, Mistral, Cohere) it uses the official `/api/v2/incidents.json` endpoint and falls back to scraping the public `/history` HTML if the JSON endpoint is empty. For Google AI it uses the dedicated `incidents.json` Google Cloud status feed.

For each incident in the window, the Actor computes an impact-weighted duration (major = 1.0, minor = 0.5, maintenance = 0.0), sums weighted downtime, and converts that into a final **uptime %**. Components affected by each incident are aggregated into a per-component breakdown so you can see, for example, that the API was down for 12 minutes and the dashboard for 47.

Apify platform advantages: schedule it weekly, hit the dataset via API, integrate with Slack/webhooks, retry on transient failures - all included.

### Why use AI Tool Uptime Leaderboard?

- **Vendor evaluation**: Compare Anthropic vs OpenAI vs Google AI reliability over the same window with the same scoring rules.
- **Trust posture**: Publish your own SLO dashboard fed by this Actor's dataset.
- **Customer reporting**: For products that depend on multiple AI providers, attach a monthly uptime report to your status page.
- **Build-vs-buy**: Quantify the reliability tax before locking into a vendor.

### How to use AI Tool Uptime Leaderboard

1. Open the Input tab.
2. Accept the default providers (5 well-known AI vendors) or paste your own list.
3. Set `daysBack` (default 30; supports 1 - 365).
4. Hit Start. Runtime is short - just incident fetches, no full crawls.
5. Inspect the Output tab. Rows are ranked by uptime %, highest first.
6. Schedule it monthly for a recurring reliability report.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `providers` | array | 5 well-known AI vendors | Each item: `{ name, statusUrl, kind }`. `kind` is `statuspage` or `gcp-json`. |
| `daysBack` | int | `30` | Time window for uptime computation. Range 1-365. |

### Output

Each dataset row = one provider (ranked):

```json
{
  "rank": 1,
  "provider": "Anthropic",
  "statusUrl": "https://status.anthropic.com",
  "windowDays": 30,
  "uptimePct": 99.847,
  "weightedDowntimeMinutes": 66.0,
  "incidentCount": 4,
  "majorIncidents": 1,
  "minorIncidents": 2,
  "componentBreakdown": [
    { "component": "console.anthropic.com", "incidentCount": 2, "downtimeMinutes": 41.0 },
    { "component": "api.anthropic.com", "incidentCount": 1, "downtimeMinutes": 25.0 }
  ],
  "incidents": [ /* up to 50 most-recent incidents inside the window */ ],
  "scannedAt": "2026-05-21T10:00:00.000Z"
}
````

A `leaderboard.json` blob with the ranked summary is also written to the key-value store. You can download the dataset in JSON, HTML, CSV, or Excel.

### Data table

| Field | Meaning |
|---|---|
| `rank` | Position in the leaderboard (1 = best uptime) |
| `provider` | Vendor name |
| `uptimePct` | Impact-weighted uptime % over the window |
| `weightedDowntimeMinutes` | Total weighted downtime in minutes |
| `incidentCount` | Total incidents recorded in window |
| `majorIncidents` | Incidents marked critical/major |
| `minorIncidents` | Incidents marked minor/medium |
| `componentBreakdown` | Per-component downtime totals |
| `incidents` | Up to 50 raw incidents with timestamps and impact |

### Pricing / Cost estimation

A typical run (5 providers, 30 days) is just a handful of HTTP calls and runs in under a minute - well under one compute unit on Apify Free for weekly or monthly schedules.

### Tips and advanced options

- **Custom providers**: append any Statuspage-powered service to the `providers` array; the `statuspage` kind covers anything served by Atlassian Statuspage.
- **Longer windows**: set `daysBack` up to 365 for annual SLO reports.
- **Impact weighting**: tweak `impactWeight()` in `src/main.js` if you want stricter or more lenient scoring (e.g., count minor incidents as 1.0).
- **GCP scope**: Google AI uses the GCP-wide feed; the Actor lightly weights non-AI services lower, but if you want strict Vertex/Gemini-only filtering, edit the `looksAI` regex.

### FAQ, disclaimers, and support

- **Public data only.** All incident data comes from public status pages and JSON endpoints; no scraping of authenticated content.
- **HTML fallback may underestimate duration.** When the JSON API is unavailable, the HTML fallback assumes 60 minutes per incident; this is conservative but rough.
- **GCP feed is broad.** Google's `incidents.json` is for the entire cloud; AI-related services are detected via component name heuristic.
- **Status pages can lag reality.** Vendor incidents are sometimes published with delay; your number is as good as the vendor's transparency.
- **Issues / feature requests**: open an issue at [github.com/ianymu](https://github.com/ianymu).
- **Verification methodology**: developed with the post-Stop verification flow at [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop).

Author: Ian Mu - One-person AI company experiments at [github.com/ianymu](https://github.com/ianymu).

# Actor input Schema

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

Each item: { name, statusUrl, kind }. 'kind' is 'statuspage' for Atlassian Statuspage sites (most providers) or 'gcp-json' for Google Cloud's incidents.json endpoint. Default covers 5 well-known AI providers.

## `daysBack` (type: `integer`):

How many days back to compute uptime over.

## Actor input object example

```json
{
  "providers": [
    {
      "name": "Anthropic",
      "statusUrl": "https://status.anthropic.com",
      "kind": "statuspage"
    },
    {
      "name": "OpenAI",
      "statusUrl": "https://status.openai.com",
      "kind": "statuspage"
    },
    {
      "name": "Google AI",
      "statusUrl": "https://status.cloud.google.com/incidents.json",
      "kind": "gcp-json"
    },
    {
      "name": "Mistral",
      "statusUrl": "https://status.mistral.ai",
      "kind": "statuspage"
    },
    {
      "name": "Cohere",
      "statusUrl": "https://status.cohere.com",
      "kind": "statuspage"
    }
  ],
  "daysBack": 30
}
```

# Actor output Schema

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/ai-tool-uptime-leaderboard").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("ianymu/ai-tool-uptime-leaderboard").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 '{}' |
apify call ianymu/ai-tool-uptime-leaderboard --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/ai-tool-uptime-leaderboard",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Tool Uptime Leaderboard",
        "description": "Compute uptime % over the past N days for each AI provider (Anthropic, OpenAI, Google AI, Mistral, Cohere, ...) using their public status pages. Outputs a ranked uptime leaderboard with incident count and per-component downtime breakdown.",
        "version": "0.0",
        "x-build-id": "g4pzk5AJNFSnqnxfx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~ai-tool-uptime-leaderboard/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-ai-tool-uptime-leaderboard",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~ai-tool-uptime-leaderboard/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-ai-tool-uptime-leaderboard",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~ai-tool-uptime-leaderboard/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-ai-tool-uptime-leaderboard",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "providers": {
                        "title": "Providers",
                        "type": "array",
                        "description": "Each item: { name, statusUrl, kind }. 'kind' is 'statuspage' for Atlassian Statuspage sites (most providers) or 'gcp-json' for Google Cloud's incidents.json endpoint. Default covers 5 well-known AI providers.",
                        "default": [
                            {
                                "name": "Anthropic",
                                "statusUrl": "https://status.anthropic.com",
                                "kind": "statuspage"
                            },
                            {
                                "name": "OpenAI",
                                "statusUrl": "https://status.openai.com",
                                "kind": "statuspage"
                            },
                            {
                                "name": "Google AI",
                                "statusUrl": "https://status.cloud.google.com/incidents.json",
                                "kind": "gcp-json"
                            },
                            {
                                "name": "Mistral",
                                "statusUrl": "https://status.mistral.ai",
                                "kind": "statuspage"
                            },
                            {
                                "name": "Cohere",
                                "statusUrl": "https://status.cohere.com",
                                "kind": "statuspage"
                            }
                        ]
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How many days back to compute uptime over.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
