# Actor Reliability Watchdog – Uptime & Schema Drift Monitor (`conceivable_extension/actor-reliability-watchdog`) Actor

Buyer-side monitoring for actors you already depend on in production. Smoke-tests each watched actor against a known-good input, compares its output schema against the fields you expect, and tracks its recent success rate — flagging silent breakage before it shows up as bad downstream data.

- **URL**: https://apify.com/conceivable\_extension/actor-reliability-watchdog.md
- **Developed by:** [joseph fadero](https://apify.com/conceivable_extension) (community)
- **Categories:** Integrations, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 actor checked healthies

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

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

## What's an Apify Actor?

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

## Actor Reliability Watchdog – Uptime & Schema Drift Monitor

**This is a buyer-side monitor, not a builder-side gap finder.**

Every "opportunity finder" or "gap finder" actor on the Apify Store targets *builders* deciding what to build next. This one is for the other side of that relationship: you already depend on 20+ actors in production — your own and third-party — and when one of them silently breaks (a target site changes its DOM, an API adds a required field, a login wall goes up), you find out when downstream data looks wrong, not when it actually broke. This actor closes that gap by actually running the actors you depend on and checking what comes back.

### What it does

For each actor you're watching:

1. Triggers a real smoke-test run with a known-good input you supply
2. Compares the returned dataset's fields against the fields you expect
3. Pulls the actor's own recent run history to compute a success rate over your check window
4. Classifies the result `ok` / `warning` / `critical` and pushes one report row per watched actor

### Input schema

```json
{
  "watchedActors": [
    {
      "actorId": "conceivable_extension/uk-business-leads",
      "expectedFields": ["companyName", "companyNumber", "sicCode"],
      "minSuccessRate": 0.9,
      "testInput": { "...": "a known-good sample input for a smoke-test run" }
    }
  ],
  "checkFrequencyHours": 24
}
```

`checkFrequencyHours` sets the look-back window for the success-rate calculation — match it to how often your schedule triggers this actor.

### Output schema

```json
{
  "actorId": "string",
  "checkedAt": "ISO timestamp",
  "runSucceeded": "boolean",
  "successRate": "number",
  "missingFields": ["array of expected fields not found in output"],
  "schemaDrift": "boolean",
  "alertLevel": "ok | warning | critical",
  "notes": "string"
}
```

### Severity thresholds

| Level | Condition |
|---|---|
| `critical` | Smoke-test run failed/timed out/errored, **or** recent success rate < 70% |
| `warning` | Run succeeded but some expected fields are missing, **or** success rate is below your `minSuccessRate` (but ≥ 70%) |
| `ok` | Run succeeded, all expected fields present, success rate ≥ `minSuccessRate` |

### Pricing

| Event | Price |
|---|---|
| Run started | £0.05 |
| Actor checked (ok) | £0.01 |
| Warning alert | £0.015 |
| Critical alert | £0.02 |

This is an internal-tool-first actor — its main value is protecting your own portfolio. Priced modestly if published, not as a primary revenue line.

### Setup note

No proxy or browser needed — this is a plain Node actor (`apify/actor-node:20` base image, no Playwright/Chrome) that calls the Apify API directly via `Actor.newClient()`. It needs your Apify API token available at runtime (automatic when run on the Apify platform) with permission to call the watched actors and read their run history.

Each smoke-test run costs whatever the watched actor itself charges (PPE or compute units) — this actor is triggering real runs, not reading cached stats, so budget for that on actors with non-trivial per-run cost.

### n8n integration

- **Workflow A (trigger):** scheduled run every 24h (or your `checkFrequencyHours`) against all actors you depend on — your own 20+ and any third-party actors your pipelines call.
- **Workflow B (processing):** on `critical` or `warning` alertLevel, push a Slack/email notification with the specific actor, its missing fields, and its last-known-good run for comparison.

# Actor input Schema

## `watchedActors` (type: `array`):

One entry per actor to monitor. Each item: { "actorId": "username/actor-name", "expectedFields": \["field1", "field2"], "minSuccessRate": 0.9, "testInput": { ...a known-good sample input for a smoke-test run } }

## `checkFrequencyHours` (type: `integer`):

Size of the look-back window used to compute each watched actor's recent success rate from its run history. Match this to how often your n8n schedule triggers this actor (e.g. 24 for a daily check).

## Actor input object example

```json
{
  "watchedActors": [
    {
      "actorId": "conceivable_extension/uk-local-business-leads",
      "expectedFields": [
        "businessName",
        "companyNumber",
        "sicCodes"
      ],
      "minSuccessRate": 0.9,
      "testInput": {
        "searchQueries": [
          "plumbers in Manchester"
        ],
        "maxResultsPerQuery": 5,
        "enrichWithCompaniesHouse": true
      }
    }
  ],
  "checkFrequencyHours": 24
}
```

# Actor output Schema

## `resultsDatasetUrl` (type: `string`):

Smoke-test results for each watched Apify actor, including dataset field-schema drift detection and recent run-health signals, produced by this run.

# 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 = {
    "watchedActors": [
        {
            "actorId": "conceivable_extension/uk-local-business-leads",
            "expectedFields": [
                "businessName",
                "companyNumber",
                "sicCodes"
            ],
            "minSuccessRate": 0.9,
            "testInput": {
                "searchQueries": [
                    "plumbers in Manchester"
                ],
                "maxResultsPerQuery": 5,
                "enrichWithCompaniesHouse": true
            }
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("conceivable_extension/actor-reliability-watchdog").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 = { "watchedActors": [{
            "actorId": "conceivable_extension/uk-local-business-leads",
            "expectedFields": [
                "businessName",
                "companyNumber",
                "sicCodes",
            ],
            "minSuccessRate": 0.9,
            "testInput": {
                "searchQueries": ["plumbers in Manchester"],
                "maxResultsPerQuery": 5,
                "enrichWithCompaniesHouse": True,
            },
        }] }

# Run the Actor and wait for it to finish
run = client.actor("conceivable_extension/actor-reliability-watchdog").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 '{
  "watchedActors": [
    {
      "actorId": "conceivable_extension/uk-local-business-leads",
      "expectedFields": [
        "businessName",
        "companyNumber",
        "sicCodes"
      ],
      "minSuccessRate": 0.9,
      "testInput": {
        "searchQueries": [
          "plumbers in Manchester"
        ],
        "maxResultsPerQuery": 5,
        "enrichWithCompaniesHouse": true
      }
    }
  ]
}' |
apify call conceivable_extension/actor-reliability-watchdog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conceivable_extension/actor-reliability-watchdog"
        }
    }
}
```

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/IGpzBmjrba3l21j5l/builds/jfOEml1A1sHA0KzHg/openapi.json