# Website Integration Health Monitor (`citric_pastel/website-integration-health-monitor`) Actor

Audit websites for broken assets, failed requests, and JavaScript errors in a real browser. Detect third-party integrations that silently stop working, and schedule repeat checks for a regression report and a health score on every page.

- **URL**: https://apify.com/citric\_pastel/website-integration-health-monitor.md
- **Developed by:** [Pavan](https://apify.com/citric_pastel) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 page audits

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Website Integration Health Monitor

**Website Integration Health Monitor** is a browser-based QA and monitoring tool for developers and agencies. It opens each page in a real browser, watches everything that loads, and flags broken behavior before a customer or teammate finds it: failed requests, JavaScript errors, broken assets, and third-party integrations that load but stop working silently.

Run it once as a production smoke test, or schedule it to run on a recurring basis and get a regression report on every check: which issues are new, which are still broken, and which have been resolved since the last run.

Enter one or more start URLs, run the Actor, and open the **Output** or **Dataset** tab to inspect a result for each audited page.

### What does the audit check?

- HTTP 4xx and 5xx responses, failed network requests, and broken images or other page assets
- Browser console errors and uncaught JavaScript exceptions; console warnings are optional
- Whether a page's third-party scripts are not just present, but actually active — for example, whether a loaded analytics script sends its expected tracking request, or a loaded payment script actually exposes a working checkout element
- A severity summary and a heuristic page health score from 0–100, so a QA pipeline or dashboard can track site reliability as a single number over time

The Actor reports `LOADED_BUT_INACTIVE` when a supported script loads but its expected activity is not observed during the visit. This is a **signal to investigate**, not proof of a broken setup — consent choices, delayed events, and user actions can affect the result.

This Actor recognizes 16 commonly used integrations across analytics, payments, chat/support, and forms (full list in the [Supported integrations](#supported-integrations) section below). For providers outside the deeper activity checks, the Actor still reports observed requests and failures.

### How do I run a website health check?

1. Enter a page in **Start URLs**. To try a public demonstration, use `https://the-internet.herokuapp.com/broken_images`.
2. For a one-page trial, set **Max pages per site** to `1` and turn off **Follow same-origin links**. Increase the limit when you want to audit more pages.
3. Click **Start** or **Run** and review the results in **Output** or **Dataset**. Each result includes an audit status, health score when conclusive, integration summary, issues, and diagnostics.
4. Open an issue's URL and message to investigate it on the site. Re-run after making a fix to confirm the regression is resolved.

Example input for the demo page:

```json
{
  "startUrls": [{ "url": "https://the-internet.herokuapp.com/broken_images" }],
  "maxPagesPerSite": 1,
  "followSameOriginLinks": false,
  "monitoringMode": true,
  "monitorId": "broken-images-demo"
}
```

### How does recurring monitoring work?

This is built to run as a **scheduled QA check**, not just a one-off scan. Enable **Compare with previous audit** (`monitoringMode`) and reuse the same **Monitor ID** for the same pages. The first completed audit saves a baseline. Later audits label current issues `NEW` or `STILL_BROKEN`, list disappeared issues under `resolvedIssues`, and calculate a `healthScoreDelta` — giving you a change-over-time regression report instead of a flat snapshot. Save the input as an Apify Task and schedule it for daily or weekly production monitoring.

The baseline is stored in a named Apify key-value store for your account, separately for each monitor ID and page URL. An `INCONCLUSIVE` audit does not replace the last completed baseline. Avoid running the same monitor ID and URLs simultaneously, because overlapping runs can compare with different saved states.

Here is a shortened example of a repeat result from the demo page. Extra third-party requests may vary between runs:

```json
{
  "url": "https://the-internet.herokuapp.com/broken_images",
  "auditStatus": "COMPLETED",
  "healthScore": 82,
  "issueSummary": { "CRITICAL": 0, "HIGH": 0, "MEDIUM": 3, "LOW": 0 },
  "issueCount": 3,
  "issues": [
    {
      "type": "BROKEN_ASSET",
      "url": "https://the-internet.herokuapp.com/asdf.jpg",
      "status": 404,
      "severity": "MEDIUM",
      "changeStatus": "STILL_BROKEN"
    },
    {
      "type": "BROKEN_ASSET",
      "url": "https://the-internet.herokuapp.com/hjkl.jpg",
      "status": 404,
      "severity": "MEDIUM",
      "changeStatus": "STILL_BROKEN"
    },
    {
      "type": "FAILED_REQUEST",
      "provider": "Optimizely",
      "severity": "MEDIUM",
      "changeStatus": "STILL_BROKEN"
    }
  ],
  "monitor": { "state": "COMPARED" },
  "newIssueCount": 0,
  "stillBrokenIssueCount": 3,
  "resolvedIssueCount": 0,
  "healthScoreDelta": 0
}
```

### How much does a website audit cost?

The current pay-per-event price is **$0.01 per page result, plus a small memory-based start charge**. Platform usage is included in those event prices. For example, one page result costs about **$0.01005**; five page results cost about **$0.05005**. Check the Actor's **Pricing** tab for the latest rates and any applicable discounts before running it.

An `INCONCLUSIVE` page still creates a dataset result explaining why the audit could not be trusted, so it counts as a charged page result. A page that fails before a result is saved does not trigger the page-result charge, although the Actor-start charge may still apply. The number of page results depends on your start URLs and crawl settings.

### What are the limits of this check?

- A human-verification or access-block page is marked `INCONCLUSIVE` and has no health score. Bot protection, consent, geography, authentication, and ad blockers can change what the browser observes.
- The Actor checks activity during a page visit. It does not click through checkout, submit forms, grant consent, or prove that a payment or analytics configuration works end to end.
- A missing integration that never loads is not automatically flagged as inactive. The loaded-but-inactive check applies after a recognized loader succeeds.
- The health score is a weighted summary of observed issues, not a performance benchmark or guarantee of business impact.
- A page that cannot be opened after retries may have no dataset item; inspect the run log in that case.

Use the findings as a starting point for investigation, and test business-critical flows separately.

### Supported integrations

Google Analytics, Google Tag Manager, Meta Pixel, Stripe, PayPal, Razorpay, HubSpot, Intercom, reCAPTCHA, Google Maps, Hotjar, Microsoft Clarity, Optimizely, Cloudinary, Shopify, Firebase.

# Actor input Schema

## `startUrls` (type: `array`):

Websites or pages to audit.

## `maxPagesPerSite` (type: `integer`):

Maximum number of same-origin pages to audit per website.

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

Number of browser pages audited in parallel.

## `pageLoadTimeoutSecs` (type: `integer`):

Navigation timeout per page in seconds.

## `waitAfterLoadMs` (type: `integer`):

Extra time after DOM load to allow integrations and API calls to fire.

## `includeConsoleWarnings` (type: `boolean`):

Include browser console warnings in the audit results in addition to console errors. Warnings are excluded by default.

## `followSameOriginLinks` (type: `boolean`):

Discover and audit internal links from each start URL.

## `expectAnalyticsFromGtm` (type: `boolean`):

Flag a loaded Google Tag Manager container when no Google Analytics collect request is seen. Enable only if this site is expected to fire GA through GTM; consent may delay the request.

## `expectStripeElements` (type: `boolean`):

Flag a loaded Stripe.js script if no Stripe Elements iframe is mounted. Enable on payment pages that should show an Elements form without another user action.

## `monitoringMode` (type: `boolean`):

Save each completed page audit in a named key-value store and report new, still-broken, and resolved issues on future runs. Inconclusive pages do not replace the baseline.

## `monitorId` (type: `string`):

Name for this monitoring workflow. Use the same ID on repeated runs; use a different ID to keep independent baselines for the same URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "maxPagesPerSite": 5,
  "maxConcurrency": 3,
  "pageLoadTimeoutSecs": 30,
  "waitAfterLoadMs": 2000,
  "includeConsoleWarnings": false,
  "followSameOriginLinks": true,
  "expectAnalyticsFromGtm": false,
  "expectStripeElements": false,
  "monitoringMode": false,
  "monitorId": "default"
}
```

# 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("citric_pastel/website-integration-health-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("citric_pastel/website-integration-health-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 '{}' |
apify call citric_pastel/website-integration-health-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,citric_pastel/website-integration-health-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/v1BRy2JpvhyxcU2Dj/builds/SI19xUfl750gaoU5d/openapi.json