# Shopify Service Status Scraper (`automation-lab/shopify-status-monitor`) Actor

Export Shopify component status, incidents, updates, and scheduled maintenance for merchant operations monitoring.

- **URL**: https://apify.com/automation-lab/shopify-status-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Shopify Service Status Scraper

Export public **Shopify service status** data as structured records for merchant operations, uptime reporting, incident review, and scheduled monitoring.

The Actor reads Shopify's public status API and returns the current overall status, component health, incident history, incident timeline updates, and scheduled maintenance. No Shopify store login or API key is required.

### What can Shopify Service Status Scraper do?

- Check whether Shopify reports an active service problem.
- Export individual component states such as Checkout and Storefront.
- Download incidents with impact, timestamps, affected components, and links.
- Turn each incident update into a separate timeline record.
- Export scheduled maintenance records.
- Filter historical event records by an ISO date-time.
- Exclude resolved incidents and completed maintenance for an active-problems view.
- Produce bounded, deduplicated records ready for schedules, webhooks, datasets, and integrations.

### Who is this Shopify status checker for?

**Merchant operations teams** can run a Shopify status check before investigating a store-side problem.

**Support teams** can correlate customer reports with Shopify incidents and update messages.

**Agencies and developers** can feed normalized status records into dashboards, Slack workflows, or incident archives.

**Analysts** can export incident history for reliability reviews without manually copying the status page.

### Why use this Actor?

Shopify's status page is useful for people, while recurring automation needs consistent records. This Actor normalizes several public API responses into one dataset with stable source IDs and a `recordType` discriminator.

It uses lightweight HTTP requests rather than a browser or proxy. Selected record types control which endpoints are requested, and `maxItems` limits saved records after filtering.

### What Shopify status data is extracted?

| Record type | Useful fields |
| --- | --- |
| `status` | Overall indicator, description, page update time |
| `component` | Component name, current status, update time |
| `incident` | Status, impact, start/resolution times, affected components, short link |
| `incidentUpdate` | Parent incident ID, update body, phase, component transitions, display time |
| `maintenance` | Maintenance status, schedule lifecycle, affected components, short link |

Every record also includes a stable `recordId`, `pageUrl`, and `scrapedAt` timestamp.

### How to run a Shopify status check

1. Open the Actor input.
2. Select the record types needed by your workflow.
3. Keep **Include resolved history** enabled for analysis, or disable it for current operational checks.
4. Optionally enter `since` as an ISO 8601 date-time.
5. Choose a `maxItems` limit from 1 to 1,000.
6. Click **Start** and open the default dataset.

A useful current-health input is:

```json
{
  "recordTypes": ["status", "component"],
  "maxItems": 25
}
```

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `recordTypes` | string array | all types | Any of `status`, `component`, `incident`, `incidentUpdate`, `maintenance` |
| `since` | ISO date-time | omitted | Filters incidents, updates, and maintenance by their latest relevant timestamp |
| `includeResolved` | boolean | `true` | Includes resolved incidents and completed maintenance |
| `maxItems` | integer | `100` | Maximum saved records, from 1 to 1,000 |

Current overall and component records are snapshots, so they remain included when `since` is set.

### Output example

A current component record looks like this:

```json
{
  "recordType": "component",
  "recordId": "xxmsk7ckz5zn",
  "name": "Checkout",
  "status": "operational",
  "description": null,
  "createdAt": "2013-07-03T21:44:09.141Z",
  "updatedAt": "2026-08-12T21:59:36.660Z",
  "pageUrl": "https://www.shopifystatus.com",
  "scrapedAt": "2026-08-13T14:15:00.000Z"
}
```

Incident-update records additionally contain `body`, `incidentId`, `displayedAt`, and component `oldStatus`/`newStatus` transitions.

### How much does it cost to monitor Shopify service status?

Pricing has a **$0.005 start fee per run** plus one `item` event for each saved dataset record. The per-record price depends on your Apify pricing tier:

| Tier | Price per saved record |
| --- | ---: |
| FREE | $0.001472 |
| BRONZE | $0.001280 |
| SILVER | $0.0009984 |
| GOLD | $0.000768 |
| PLATINUM | $0.000512 |
| DIAMOND | $0.0003584 |

At the BRONZE rate, a 10-record health check costs about **$0.0178**, a 100-record incident export about **$0.133**, and 1,000 saved records about **$1.285**. Failed, filtered, duplicate, and unsaved source objects do not create an item event.

### Schedule recurring Shopify status monitoring

Create an Apify schedule for the Actor and use a webhook after successful runs. For an active-event monitor, select `status`, `incident`, `incidentUpdate`, and `maintenance`, then set `includeResolved` to `false`.

Stable `recordType:id` pairs make it straightforward for downstream systems to detect newly seen records or changed statuses. The Actor itself exports snapshots; it does not persist a cross-run diff or send alerts on its own.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~shopify-status-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"recordTypes":["incident","incidentUpdate"],"includeResolved":true,"maxItems":100}'
```

Use `run-sync-get-dataset-items` when a calling environment can wait for the result:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~shopify-status-monitor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"recordTypes":["status","component"],"maxItems":25}'
```

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/shopify-status-monitor').call({
  recordTypes: ['status', 'incident', 'incidentUpdate'],
  includeResolved: false,
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/shopify-status-monitor").call(run_input={
    "recordTypes": ["incident", "maintenance"],
    "includeResolved": True,
    "maxItems": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/shopify-status-monitor"
```

#### Claude Desktop, Cursor, and VS Code MCP setup

Use this equivalent JSON configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/shopify-status-monitor"
    }
  }
}
```

Example prompts:

- “Check Shopify's current overall and component status.”
- “Export Shopify incidents and their timeline updates.”
- “Return active Shopify incidents or maintenance records for my operations report.”

### Integration ideas

- Send active event records to Slack, Teams, email, or PagerDuty through an Apify webhook and an automation platform.
- Load incident and update records into BigQuery, Snowflake, PostgreSQL, or a spreadsheet.
- Compare stable IDs and statuses with the previous run in Make, Zapier, n8n, or your own worker.
- Attach a status snapshot to merchant-support tickets.
- Build a lightweight uptime evidence archive for post-incident reviews.

### Limits and failure behavior

The Actor reflects what Shopify publishes on `shopifystatus.com`; it does not test an individual store, checkout, app, payment provider, or network path.

Historical coverage is limited to records returned by Shopify's public Statuspage API. `since` cannot recover events omitted by that source.

The public API may change, rate-limit, or become unavailable. Requests have bounded timeouts and transient retries. A persistent HTTP or schema error fails the run clearly rather than returning fabricated results.

A successful active-problems run can contain only the overall `status` record when Shopify reports no active incident or maintenance event.

### Tips for reliable workflows

- Use `status` and `component` for a fast current snapshot.
- Include `incidentUpdate` when update text and component transitions matter.
- Keep `includeResolved: true` for historical exports.
- Use `since` plus a schedule to reduce repeated historical records downstream.
- Start with a small `maxItems`, inspect the schema, then raise it for exports.
- Deduplicate downstream with `recordType` and `recordId`, not names.

### Legality and responsible use

The Actor accesses public operational-status information without authentication. Use the data responsibly and comply with Shopify's terms, Apify's terms, and applicable laws. Do not present Shopify's general status as proof that a specific merchant store or integration is healthy.

### Troubleshooting

#### Why do I only see one record?

If `includeResolved` is disabled and Shopify has no active event, the overall status snapshot may be the only matching record. Enable resolved history or add `component` records for a broader dataset.

#### Why are old incidents missing?

Check the `since` value and `maxItems`. Shopify also controls the history available through its public API.

#### Why did the run fail with an upstream error?

Shopify's status API may be temporarily unavailable or may have changed its response. Retry later after checking the source page; persistent failures are surfaced to prevent misleading output.

### Frequently asked questions

#### Does this check my Shopify store?

No. It exports Shopify's published platform status. It does not probe a merchant storefront or Admin account.

#### Does it require Shopify credentials?

No. It uses public status endpoints.

#### Can it send alerts?

Use an Apify schedule and webhook to connect the output to your alerting tool. The Actor does not send notifications directly.

#### Are incident updates separate records?

Yes. Select `incidentUpdate` to receive each public timeline update with its parent incident ID.

### Related automation-lab Actors

- [HTTP Status Checker](https://apify.com/automation-lab/http-status-checker) checks the HTTP responses of URLs you control.
- [Website Change Monitor](https://apify.com/automation-lab/website-change-monitor) tracks changes on arbitrary web pages.
- [CPSC Product Recalls Monitor](https://apify.com/automation-lab/cpsc-product-recalls-monitor) exports official product-recall records for compliance monitoring.

These Actors solve different monitoring jobs; combine them only when the workflow needs both platform-status context and target-specific checks.

# Actor input Schema

## `recordTypes` (type: `array`):

Status records to save. Incident updates are separate timeline records for monitoring and alerting workflows.

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

Optional ISO 8601 date-time. Incidents, updates, and maintenance older than this are omitted. Current overall and component status remain included.

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

Include resolved incidents and completed maintenance. Disable this for a current-problems check.

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

Maximum number of records saved after filtering, from newest to oldest.

## Actor input object example

```json
{
  "recordTypes": [
    "status",
    "component",
    "incident",
    "incidentUpdate",
    "maintenance"
  ],
  "includeResolved": true,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with all selected status record types.

# 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 = {
    "recordTypes": [
        "status",
        "component",
        "incident",
        "incidentUpdate",
        "maintenance"
    ],
    "includeResolved": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shopify-status-monitor").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 = {
    "recordTypes": [
        "status",
        "component",
        "incident",
        "incidentUpdate",
        "maintenance",
    ],
    "includeResolved": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/shopify-status-monitor").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 '{
  "recordTypes": [
    "status",
    "component",
    "incident",
    "incidentUpdate",
    "maintenance"
  ],
  "includeResolved": true,
  "maxItems": 20
}' |
apify call automation-lab/shopify-status-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/shopify-status-monitor"
        }
    }
}

```

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/AwTbbrxZjmZ3ZbCbN/builds/qlw4QYkG4Yl7UGQJE/openapi.json