# ReleaseProof — Website Visual Regression QA (`al_mansouri/releaseproof`) Actor

Compare preview and production pages across mobile, tablet, and desktop. Catch visual regressions, overflow, broken assets, and browser errors in a shareable QA report.

- **URL**: https://apify.com/al\_mansouri/releaseproof.md
- **Developed by:** [Hussein Al-Mansori](https://apify.com/al_mansouri) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 page auditeds

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

## ReleaseProof — visual evidence before you ship

ReleaseProof compares authorized public preview and production pages across mobile, tablet, and
desktop. It produces responsive screenshots, red-highlight visual differences, browser findings,
and a shareable QA report your team or client can review without installing a test framework.

**[Open a real ReleaseProof example report](https://api.apify.com/v2/key-value-stores/sLSLB1nHdFIehMGum/records/report.html)**

### Why teams use ReleaseProof

- **Review a release before launch.** See the candidate page at three practical viewport sizes.
- **Compare preview with production.** Match every candidate path and query to one production origin.
- **Catch observable problems.** Find horizontal overflow, failed assets, browser errors, blocked
  pages, timeouts, and unexpectedly tall screenshots.
- **Share proof, not a vague score.** Send one read-only HTML report with the screenshots, findings,
  visual diffs, JSON, and CSV.
- **Keep failures honest.** A navigation or processing failure is reported as failed, blocked,
  timed out, or unknown—never silently converted into a pass.

ReleaseProof is useful for agency handoffs, landing-page launches, redesigns, CMS changes,
e-commerce releases, and regression checks where a visual record matters.

### What one audit includes

For every submitted page, ReleaseProof can provide:

- full-page PNG screenshots at mobile (390×844), tablet (768×1024), and desktop (1440×900);
- isolated candidate and production-baseline captures for each selected device;
- a changed-pixel percentage and red-highlight diff image when comparison succeeds;
- final URL and main-document HTTP status;
- console errors, uncaught page errors, and failed image, font, stylesheet, script, XHR, or fetch
  requests;
- horizontal-overflow evidence with up to 20 visible offending elements;
- page dimensions and clear screenshot-truncation disclosure;
- one ordered dataset row plus matching HTML, JSON, and CSV outputs.

URL order and duplicates are preserved. One problem page does not cancel unrelated pages.

### How it works

1. **Add 1–20 candidate URLs.** These must be public pages you own or are authorized to assess.
2. **Optionally add the production origin.** ReleaseProof appends each candidate path and query to
   that origin. For example, `https://preview.example.com/pricing?currency=usd` is compared with
   `https://example.com/pricing?currency=usd`.
3. **Choose the devices and run.** Open the HTML report from the Output tab and share its
   hard-to-guess link with the people reviewing the release.

```json
{
  "urls": [
    "https://preview.example.com/pricing?currency=usd"
  ],
  "baselineBaseUrl": "https://example.com",
  "devices": ["mobile", "tablet", "desktop"],
  "navigationTimeoutSeconds": 45,
  "settleTimeMilliseconds": 1500,
  "confirmAuthorization": true
}
```

### Result statuses

| Status | Meaning |
| --- | --- |
| `passed` | Every requested capture completed with no reportable findings. |
| `warning` | Capture succeeded with browser errors, failed resources, truncation, or at least 1% visual difference. |
| `failed` | The main document returned another HTTP error, or horizontal overflow exceeded 2 CSS pixels. |
| `blocked` | The site returned 401/403/407/429/451, showed a recognized challenge, or attempted an unsafe redirect. |
| `timed_out` | Navigation or capture exceeded its configured deadline. |
| `unknown` | DNS, browser, capture, comparison, or another indeterminate failure prevented a reliable conclusion. |

Visual difference is evidence, not automatic proof of a defect. A person should review the images.

### Transparent pricing

- **$0.05 per submitted page audit.** Every selected device, optional production comparison,
  screenshots, available diff images, findings, HTML report, JSON, and CSV are included.
- **$0.00005 Actor-start event per GB of configured memory.** The default 2 GB run therefore adds
  $0.00010 once per run.
- **Platform usage is included.** Customers do not receive a separate infrastructure charge.

One URL is one page audit. At the default memory, 1 page costs about **$0.05010**, 10 pages about
**$0.50010**, and 20 pages about **$1.00010**.

The page event is charged only after the report, exports, dataset row, screenshots, and available
diffs have been stored successfully. A `failed`, `blocked`, `timed_out`, or `unknown` page remains a
completed audit when ReleaseProof delivered the promised evidence. Invalid input does not produce a
page-audit charge.

You can set a maximum run charge in Apify. ReleaseProof checks that it covers all submitted pages
before opening Chromium.

### Trust, safety, and privacy

ReleaseProof is deliberately narrow and evidence-based:

- it accepts public HTTP(S) pages only—no credentials, cookies, custom headers, proxies, CAPTCHA
  solving, or login automation;
- it blocks localhost, private, link-local, reserved, cloud-metadata, credential-bearing,
  non-HTTP, and browser-internal URLs on initial requests, redirects, and subrequests;
- candidate and baseline pages run in isolated browser contexts;
- diagnostic resource URLs are stored without query strings, and message counts are bounded;
- reports contain no ReleaseProof tracking scripts and are rendered from autoescaped data;
- no AI model assigns design scores or invents findings.

Run artifacts are intentionally readable by anyone possessing their hard-to-guess storage URL and
remain available according to the customer's Apify storage-retention policy. Do not submit private
or secret information through public page URLs.

### Honest limits

- Screenshots are capped at 16,000 CSS pixels and explicitly marked when truncated.
- Dynamic content, consent dialogs, ads, dates, live inventory, and experiments can create
  legitimate visual differences.
- ReleaseProof observes the loaded page; it does not click through flows or validate business logic.
- Scheduled monitoring, Lighthouse, accessibility/SEO audits, PDF reports, custom branding,
  authentication, and AI design criticism are not included in this version.

ReleaseProof reports observable browser evidence, not a guarantee of correctness, accessibility,
security, or legal compliance. Test only pages you own or are authorized to assess, and review the
evidence before making release decisions.

# Actor input Schema

## `urls` (type: `array`):

Enter complete HTTP(S) page URLs. Order and duplicates are preserved.

## `baselineBaseUrl` (type: `string`):

Enter an origin only, such as https://example.com. ReleaseProof appends every candidate path and query. Leave blank for responsive screenshots without visual comparison.

## `devices` (type: `array`):

Choose one or more viewport presets. Captures use device scale factor 1.

## `confirmAuthorization` (type: `boolean`):

Required. By running ReleaseProof, you confirm that you own or have permission to assess every candidate and baseline page.

## `navigationTimeoutSeconds` (type: `integer`):

Maximum time allowed for each page and device navigation/capture.

## `settleTimeMilliseconds` (type: `integer`):

Extra delay after fonts load and ReleaseProof scrolls the page to trigger lazy content.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "devices": [
    "mobile",
    "tablet",
    "desktop"
  ],
  "confirmAuthorization": true,
  "navigationTimeoutSeconds": 45,
  "settleTimeMilliseconds": 1500
}
```

# Actor output Schema

## `report` (type: `string`):

Open the shareable, read-only visual QA report with screenshots and findings.

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

One nested result row for every submitted page.

## `json` (type: `string`):

Portable machine-readable results in original input order.

## `csv` (type: `string`):

Spreadsheet-friendly page results with nested device data.

## `screenshots` (type: `string`):

No description

## `diffs` (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 = {
    "urls": [
        "https://example.com/"
    ],
    "confirmAuthorization": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("al_mansouri/releaseproof").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 = {
    "urls": ["https://example.com/"],
    "confirmAuthorization": True,
}

# Run the Actor and wait for it to finish
run = client.actor("al_mansouri/releaseproof").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 '{
  "urls": [
    "https://example.com/"
  ],
  "confirmAuthorization": true
}' |
apify call al_mansouri/releaseproof --silent --output-dataset

```

## MCP server setup

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

```

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/LdF3b4UF62gNkwlV3/builds/Z6ukMYmDn3f4fx5UE/openapi.json