# GitHub Status History Scraper (`parseforge/github-status-history-scraper`) Actor

Export GitHub status, incidents, scheduled maintenances, and components from the public status page. Track Git, Actions, Pages, API, Codespaces uptime and incident history. Filter by component or date.

- **URL**: https://apify.com/parseforge/github-status-history-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🐙 GitHub Status History Scraper

> 🚀 **Export GitHub uptime and incident history in seconds.** Pull live status, recent incidents, unresolved outages, scheduled maintenance, and component health across **Git Operations, Actions, Pages, Packages, Webhooks, Issues, Codespaces**, and more. No login, no manual page scrolling.

> 🕒 **Last updated:** 2026-05-22 · **📊 19 fields** per record · **🐙 19 monitored components** · **🚨 5 query modes** · **🌐 statuspage.io feed**

The **GitHub Status History Scraper** exports the live status page and returns **19 fields per record**, including record type, incident name, severity impact, current status, monitoring and resolution timestamps, affected components, latest update text, update counts, and a permalink shortlink to the incident page. The underlying source is the official GitHub status feed powered by Statuspage.io and used by GitHub's own SRE team.

The dataset covers **19 monitored components** (Git Operations, Actions, Packages, Pages, Webhooks, API Requests, Issues, Pull Requests, Codespaces, Copilot, GitHub Mobile, and more), the **recent incident archive**, **unresolved incidents**, and **upcoming scheduled maintenance windows**. This Actor turns that history into a downloadable dataset as CSV, Excel, JSON, or XML in under five minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| DevOps teams, SRE engineers, monitoring vendors, on-call leads, CI/CD platform owners, status-dashboard builders | Uptime dashboards, on-call paging, incident postmortems, vendor SLA tracking, multi-cloud status walls, deploy-window planning |

---

### 📋 What the GitHub Status Scraper does

Five query workflows in a single run:

- 🚦 **Overall summary.** Current top-level status plus any open incidents.
- 🚨 **All recent incidents.** The full archive of recent outages and degradations.
- 🔧 **Unresolved incidents.** Only the incidents that are still active.
- 📅 **Scheduled maintenances.** Planned maintenance windows ahead of time.
- 🧩 **Components list.** Every monitored component with its current health.

Each record bundles type (incident, maintenance, component, summary), severity impact, lifecycle timestamps (created, updated, monitoring, resolved), affected component names and IDs, the latest status update text, and a direct shortlink to the incident on the status page.

> 💡 **Why it matters:** GitHub outages cascade into every team's CI pipeline, code review queue, and production deploy. Knowing about a degradation 30 seconds before the support tickets land is the difference between a calm rollback and a fire drill.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>enum</td><td><code>"incidents"</code></td><td>Which slice to export: <code>summary</code>, <code>incidents</code>, <code>unresolved</code>, <code>scheduled</code>, or <code>components</code>.</td></tr>
<tr><td><code>since</code></td><td>string</td><td><code>""</code></td><td>Optional ISO date floor. Only incidents created on or after this date.</td></tr>
<tr><td><code>componentFilter</code></td><td>string</td><td><code>""</code></td><td>Optional substring match against component names like <code>Actions</code> or <code>API Requests</code>.</td></tr>
</tbody>
</table>

**Example: recent Actions incidents from January 2026 onward.**

```json
{
    "maxItems": 50,
    "mode": "incidents",
    "since": "2026-01-01",
    "componentFilter": "Actions"
}
````

**Example: all currently monitored components and their state.**

```json
{
    "maxItems": 20,
    "mode": "components"
}
```

> ⚠️ **Good to Know:** the status feed is updated by GitHub's SRE team in near-real-time but may lag actual user-visible impact by 30 to 60 seconds. For mission-critical alerting, combine with a synthetic monitoring layer that exercises the workflows you actually care about.

***

### 📊 Output

Each record contains **19 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `recordType` | string | `"incident"` |
| 🆔 `id` | string | `"a1b2c3d4e5f6"` |
| 📝 `name` | string | `"Incident with Actions"` |
| 🚦 `status` | string | `"resolved"` |
| ⚠️ `impact` | string | `"minor"` |
| 🚨 `incidentImpact` | string | `"minor"` |
| 👀 `monitoringAt` | ISO 8601 | `"2026-05-20T14:22:00.000Z"` |
| ✅ `resolvedAt` | ISO 8601 | null | `"2026-05-20T14:48:00.000Z"` |
| 📅 `scheduledFor` | ISO 8601 | null | `null` |
| 📅 `scheduledUntil` | ISO 8601 | null | `null` |
| 📅 `scheduledStatus` | string | null | `null` |
| 🕒 `createdAt` | ISO 8601 | `"2026-05-20T14:10:00.000Z"` |
| 🕒 `updatedAt` | ISO 8601 | `"2026-05-20T14:48:00.000Z"` |
| 🔗 `shortlink` | string | `"https://stspg.io/abc123"` |
| 🧩 `affectedComponents` | array | `["Actions", "Webhooks"]` |
| 🆔 `componentIds` | array | `["br0l2tvcx85d", "4230lsnqdsld"]` |
| 💬 `latestUpdate` | string | `"This incident has been resolved."` |
| 🔢 `updatesCount` | number | `4` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |
| ⚠️ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>🚨 Resolved Actions incident</strong></summary>

```json
{
    "recordType": "incident",
    "id": "a1b2c3d4e5f6",
    "name": "Incident with Actions",
    "status": "resolved",
    "impact": "minor",
    "incidentImpact": "minor",
    "monitoringAt": "2026-05-20T14:22:00.000Z",
    "resolvedAt": "2026-05-20T14:48:00.000Z",
    "scheduledFor": null,
    "scheduledUntil": null,
    "scheduledStatus": null,
    "createdAt": "2026-05-20T14:10:00.000Z",
    "updatedAt": "2026-05-20T14:48:00.000Z",
    "shortlink": "https://stspg.io/abc123",
    "affectedComponents": ["Actions", "Webhooks"],
    "componentIds": ["br0l2tvcx85d", "4230lsnqdsld"],
    "latestUpdate": "This incident has been resolved.",
    "updatesCount": 4,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📅 Scheduled maintenance window</strong></summary>

```json
{
    "recordType": "maintenance",
    "id": "f6e5d4c3b2a1",
    "name": "Scheduled maintenance for Packages",
    "status": "scheduled",
    "impact": "maintenance",
    "incidentImpact": "maintenance",
    "monitoringAt": null,
    "resolvedAt": null,
    "scheduledFor": "2026-05-25T03:00:00.000Z",
    "scheduledUntil": "2026-05-25T05:00:00.000Z",
    "scheduledStatus": "scheduled",
    "createdAt": "2026-05-18T09:00:00.000Z",
    "updatedAt": "2026-05-18T09:00:00.000Z",
    "shortlink": "https://stspg.io/xyz789",
    "affectedComponents": ["Packages"],
    "componentIds": ["brv1bkgrwx7q"],
    "latestUpdate": "Scheduled maintenance is planned during the listed window.",
    "updatesCount": 1,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🧩 Component health record: API Requests</strong></summary>

```json
{
    "recordType": "component",
    "id": "br0l2tvcx85d",
    "name": "API Requests",
    "status": "operational",
    "impact": null,
    "incidentImpact": null,
    "monitoringAt": null,
    "resolvedAt": null,
    "scheduledFor": null,
    "scheduledUntil": null,
    "scheduledStatus": null,
    "createdAt": "2017-01-31T20:01:46.000Z",
    "updatedAt": "2026-05-22T00:00:00.000Z",
    "shortlink": null,
    "affectedComponents": [],
    "componentIds": [],
    "latestUpdate": null,
    "updatesCount": 0,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚦 | **Five query modes.** Summary, incidents, unresolved, scheduled maintenance, and components, all from one Actor. |
| 🧩 | **Component-level granularity.** Filter by Actions, Pages, API Requests, Codespaces, Copilot, or any of the 19 monitored components. |
| 📅 | **Lifecycle timestamps.** Created, updated, monitoring, and resolved times let you compute mean-time-to-resolve. |
| 🔁 | **Always fresh.** Every run reads the live status feed so unresolved incidents update in near real time. |
| 🔗 | **Permalink shortlinks.** Direct deep links into the official incident page for embedded dashboards. |
| 📊 | **Multi-cloud ready.** Combine with other status scrapers to power a unified status wall for your stack. |
| 🚫 | **No authentication.** Public status feed. No login or token. |

> 📊 GitHub powers most of the world's source control, CI pipelines, and developer collaboration. Knowing its health is the foundation of every modern engineering dashboard.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ GitHub Status Scraper** *(this Actor)* | $5 free credit, then pay-per-use | All components + incidents | **Live per run** | mode, date, component | ⚡ 2 min |
| RSS subscription | Free | Recent incidents | Pull-driven | None | 🐢 Minutes |
| Statuspage.io paid integration | $79+/month | One vendor at a time | Webhook | Few | ⏳ Hours |
| Hand-built scraper | Free | Whatever you parse | Whatever you cron | None | 🕒 Days |

Pick this Actor when you want clean structured records, component filtering, and a dataset you can hand straight to your monitoring stack.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the GitHub Status History Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode (incidents, components, scheduled), and add optional date or component filters.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your dataset.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🚨 SRE & On-Call

- Mirror live incident state into PagerDuty
- Auto-page on-call when CI-critical components degrade
- Compute MTTR and incident frequency by component
- Build internal status walls for engineering floors

</td>
<td width="50%" valign="top">

#### 📊 Engineering Dashboards

- Embed live GitHub health into team dashboards
- Combine with AWS, Cloudflare, npm status for a unified view
- Surface upcoming maintenance to plan deploy windows
- Track open incidents next to your own service SLOs

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📝 Postmortems & Reporting

- Pull resolved-incident timelines into postmortem templates
- Reconstruct outage windows for SLA reporting
- Annotate your own incidents with upstream root causes
- Generate monthly vendor-health reports

</td>
<td width="50%" valign="top">

#### 🔌 Monitoring Vendors

- Ingest GitHub health into Datadog, Grafana, New Relic
- Power a customer-facing status integration
- Enrich uptime data with incident severity context
- Sell vendor-status add-ons in your monitoring suite

</td>
</tr>
</table>

***

### 🔌 Automating GitHub Status Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Run every 60 seconds to track unresolved incidents, or daily to feed monthly vendor-health reports.

***

### 🌟 Beyond business use cases

Status data powers more than commercial workflows. The same records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Reliability engineering case studies
- Distributed-systems coursework with real outage data
- Reproducible incident analyses with versioned dataset pulls
- Open-data exercises on platform availability

</td>
<td width="50%">

#### 🎨 Personal and creative

- Hobby uptime dashboards on a Raspberry Pi
- Side projects on incident-pattern visualization
- Personal Slack bots that announce GitHub outages
- Curated newsletters on major dev-platform incidents

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Open-source maintainer dashboards for OSS communities
- Civic transparency around infrastructure availability
- Investigative journalism on platform reliability
- Public-good incident archives for ecosystem research

</td>
<td width="50%">

#### 🧪 Experimentation

- Train anomaly-detection or incident-clustering models
- Validate alerting hypotheses with historical incidents
- Prototype agent pipelines that triage status changes
- Stress-test dashboard layouts with real data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20GitHub%20Status%20History%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20GitHub%20Status%20History%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20GitHub%20Status%20History%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20GitHub%20Status%20History%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a query mode, add optional date or component filters, click Start, and the Actor reads the live GitHub status feed and emits structured records. No browser automation, no captchas, no setup.

#### 📏 How fresh is the data?

The status feed is maintained by GitHub's SRE team in near-real-time and typically lags actual user-visible impact by 30 to 60 seconds. Every run of this Actor reads the current feed at fetch time.

#### 🚨 What counts as an incident?

Anything GitHub publishes on the status page, from full outages to minor service degradations. The `impact` field tells you the severity tier: none, minor, major, critical, or maintenance.

#### 🧩 How many components are tracked?

GitHub currently exposes 19 monitored components, including Git Operations, Actions, Packages, Pages, Webhooks, API Requests, Issues, Pull Requests, Codespaces, Copilot, and GitHub Mobile.

#### ⏰ Can I run this every minute?

Yes. Use Apify Schedules with a one-minute cron expression to keep an unresolved-incidents stream flowing into your monitoring stack.

#### 🔁 Can I scrape historical incidents?

Yes. The `since` filter lets you backfill from any ISO date. The recent-incidents archive holds several months of history at any given time.

#### 📊 Does it include the per-update timeline of an incident?

Each record exposes the latest update text and the total update count. To pull every update body, run with mode `incidents` and follow the shortlink for the human-readable history.

#### 💼 Can I use this data commercially?

Yes. The status feed is published openly. Review GitHub's terms of service for your specific use case before embedding the data in a paid product.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small pulls (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

GitHub Status History Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get incident notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe status records into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Page on-call when an unresolved incident appears, or update a status wall in Slack.

***

### 🔗 Recommended Actors

- [**📜 RFC Editor Index Scraper**](https://apify.com/parseforge/rfc-editor-scraper) - IETF Internet standards catalog
- [**🌐 IP Geolocation Scraper**](https://apify.com/parseforge/ipapi-geolocation-scraper) - Bulk IPv4/IPv6 geolocation lookups
- [**📚 Internet Archive Search Scraper**](https://apify.com/parseforge/internet-archive-search-scraper) - 50M+ archived texts, audio, video, software
- [**☁️ AWS Status Scraper**](https://apify.com/parseforge/aws-status-scraper) - Live AWS service health and incidents
- [**🌍 REST Countries Info Scraper**](https://apify.com/parseforge/restcountries-info-scraper) - 250+ countries with population, currencies, languages

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more developer-tools scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by GitHub, Microsoft, or Statuspage.io. All trademarks mentioned are the property of their respective owners. Only publicly available status data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `mode` (type: `string`):

Which dataset to retrieve.

## `since` (type: `string`):

Optional. Only return incidents created on or after this ISO date (e.g. '2026-01-01').

## `componentFilter` (type: `string`):

Optional. Only return records affecting components whose name contains this string (e.g. 'Actions', 'Pages', 'API Requests').

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "incidents"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "mode": "incidents"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/github-status-history-scraper").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 = {
    "maxItems": 10,
    "mode": "incidents",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/github-status-history-scraper").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 '{
  "maxItems": 10,
  "mode": "incidents"
}' |
apify call parseforge/github-status-history-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Status History Scraper",
        "description": "Export GitHub status, incidents, scheduled maintenances, and components from the public status page. Track Git, Actions, Pages, API, Codespaces uptime and incident history. Filter by component or date.",
        "version": "1.0",
        "x-build-id": "D5FcDiYKB2rhoudpa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~github-status-history-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-github-status-history-scraper",
                "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/parseforge~github-status-history-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-github-status-history-scraper",
                "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/parseforge~github-status-history-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-github-status-history-scraper",
                "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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "summary",
                            "incidents",
                            "unresolved",
                            "scheduled",
                            "components"
                        ],
                        "type": "string",
                        "description": "Which dataset to retrieve."
                    },
                    "since": {
                        "title": "Since (ISO Date)",
                        "type": "string",
                        "description": "Optional. Only return incidents created on or after this ISO date (e.g. '2026-01-01')."
                    },
                    "componentFilter": {
                        "title": "Component Filter",
                        "type": "string",
                        "description": "Optional. Only return records affecting components whose name contains this string (e.g. 'Actions', 'Pages', 'API Requests')."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
