# Website Content & Responsive UX Audit (`bread-kim/website-content-responsive-ux-audit`) Actor

Audit server-rendered website content and responsive layouts. Get desktop/mobile screenshots, measured usability checks, and developer-ready findings in a downloadable report pack. Site JavaScript is not executed.

- **URL**: https://apify.com/bread-kim/website-content-responsive-ux-audit.md
- **Developed by:** [bread kim](https://apify.com/bread-kim) (community)
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 website audit reports

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 Content & Responsive UX Evidence Audit

Private Apify Actor for developers and agencies preparing a client handoff. It fetches one caller-declared public HTTPS page, keeps server-rendered HTML plus bounded same-origin CSS, renders fresh 1440×900 and 390×844 Chromium contexts with JavaScript disabled, and produces measured screenshots, observations, acceptance checks, and a portable hashed report pack.

It does **not** perform real-user testing, automatic redesign, conversion optimization, interactive-JavaScript testing, or usability/WCAG certification. Missing expectations remain `NOT_PROVIDED`; the Actor never invents business intent. Form/control state and ordinary anchor semantics are preserved for accurate rendering while submission actions, site JavaScript, and all browser requests are blocked; image boxes become explicitly reported layout approximations, and safe charset/viewport metadata is retained. Images, fonts, scripts, iframes, media, third-party resources, CSS imports, and CSS URL assets are not fetched. Unknown, imported, or omitted styles produce prominent partial-coverage warnings. Challenge and script-only pages fail as unsupported instead of producing a clean-looking audit.

### Input and output

Set `demoMode: true` for the deterministic built-in fixture (no DNS or HTTP). Live mode requires one public HTTPS URL with no credentials, custom port, query, hash, or IP literal. Optional `expectedPrimaryAction`, up to five literal `expectedMessageTerms`, and `audience` are caller declarations.

Successful runs write one default-dataset summary and `OUTPUT`, `UX_AUDIT.json`, `UX_FINDINGS.csv`, `UX_REPORT.html`, `DESKTOP.png`, `MOBILE.png`, `HANDOFF.md`, `MANIFEST.json`, and `UX_AUDIT_PACK.zip` to the default key-value store. Output provenance records `DEMO` or `LIVE`, normalized requested URL, verified final URL, and observation time; demo URL fields remain null. To avoid an impossible self-referential hash, packaged `UX_AUDIT.json` identifies the archive with `convention: EXTERNAL_OUTPUT_ONLY` but excludes the outer ZIP hash/size. The external authoritative `OUTPUT` adds the exact final ZIP SHA-256 and byte count. Standalone `HANDOFF.md` is the same byte string listed in the manifest and ZIP. Failed runs write only a safe failed `OUTPUT` and no success dataset item; invalid/missing input preserves the operator contract `error.code: INVALID_INPUT` with process exit 0.

### Local verification

Use Node 22.23.3: `npm ci --ignore-scripts`, `npm test`, `npm run typecheck`, `npm run preflight`. Local Chromium proof uses only task-owned `.native-test-libs` extracted from the pinned `@sparticuz/chromium` AL2023 bundle; that folder and `.npm-cache` are excluded from the image/upload context. The Docker image expands Chromium once during build into immutable `/opt/ux-chromium` and performs a real deterministic render self-check. Runtime never accepts a customer or environment executable path. Before any remote mutation, the signed operator still must build once and run the isolated smoke; no Docker execution or deployment was performed here.

Public page screenshots can contain public PII. Only audit pages you are authorized to review. Raw headers, credentials, cookies, and source HTML are never stored.

Overlap analysis samples the first 100 visible controls and retains at most 50 pair observations per viewport. `OVERLAP_CHECK_LIMIT_REACHED` explicitly marks untested remaining pairs; an omitted finding is not proof of no overlap. This bounds pairwise memory/compute even on dense hostile pages.

On a fresh Linux test checkout without Chromium native dependencies, extract the pinned package's bundled libraries into the ignored, task-owned folder (no system package installation):

```sh
mkdir -p .native-test-libs
TMPDIR="$PWD/.native-test-libs" node --input-type=module -e 'import { inflate } from "@sparticuz/chromium"; await inflate("node_modules/@sparticuz/chromium/bin/al2023.tar.br")'
npm run preflight
```

# Actor input Schema

## `demoMode` (type: `boolean`):

Use the built-in no-network fixture.

## `url` (type: `string`):

Required in live mode. Query strings, credentials, ports, and IP literals are rejected.

## `expectedPrimaryAction` (type: `string`):

Optional caller-declared visible action text; absence remains NOT_PROVIDED.

## `expectedMessageTerms` (type: `array`):

Up to five literal visible message terms.

## `audience` (type: `string`):

Optional caller context; no intent is invented.

## Actor input object example

```json
{
  "demoMode": true
}
```

# Actor output Schema

## `output` (type: `string`):

Run status, evidence contract, and exact outer ZIP hash/size.

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

Exactly one successful summary row.

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

Escaped static evidence report.

## `desktop` (type: `string`):

Measured 1440 by 900 browser evidence.

## `mobile` (type: `string`):

Measured 390 by 844 browser evidence.

## `zip` (type: `string`):

Hashed seven-entry portable bundle; packaged audit intentionally excludes the self-referential outer ZIP hash/size.

# 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 = {
    "demoMode": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("bread-kim/website-content-responsive-ux-audit").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 = { "demoMode": True }

# Run the Actor and wait for it to finish
run = client.actor("bread-kim/website-content-responsive-ux-audit").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 '{
  "demoMode": true
}' |
apify call bread-kim/website-content-responsive-ux-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bread-kim/website-content-responsive-ux-audit"
        }
    }
}
```

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/8imUpN25bGRgIs9LG/builds/UJJcOieEVKb73LueW/openapi.json