# Website Quality Audit (`hamzamihaidaniel/siteone-website-audit`) Actor

Audit public websites for SEO, security, accessibility, performance, redirects, and technical issues. Get structured results plus interactive HTML and JSON reports.

- **URL**: https://apify.com/hamzamihaidaniel/siteone-website-audit.md
- **Developed by:** [Hamza Mihai Daniel](https://apify.com/hamzamihaidaniel) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 page scanneds

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

## SiteOne Website Audit Actor

Audit a public website for SEO, security, accessibility, performance, and
best-practice problems. The Actor wraps the open-source
[SiteOne Crawler](https://github.com/janreges/siteone-crawler) and turns its
reports into Apify-native datasets and files.

### What you get

- Overall website quality score from 0 to 10.
- Category scores for performance, SEO, security, accessibility, and best practices.
- One dataset row for each audited HTML page or redirect.
- Actionable critical, warning, and notice findings.
- A complete structured JSON report.
- A self-contained interactive HTML report.
- Scheduling, API, webhook, Make, Zapier, n8n, and MCP compatibility through Apify.

### Input

| Field | Description | Default |
| --- | --- | --- |
| `startUrl` | Public HTTP or HTTPS website | Required |
| `preset` | HTML report focus | `full` |
| `singlePage` | Audit only the start page | `false` |
| `device` | Desktop, mobile, or tablet user agent | `desktop` |
| `maxVisitedUrls` | Maximum pages and assets fetched | `100` |
| `maxDepth` | Maximum page path depth; `0` is unlimited | `0` |
| `requestsPerSecond` | Global request rate | `5` |
| `workers` | Concurrent requests | `2` |
| `timeoutSecs` | Per-request timeout | `10` |
| `removeQueryParameters` | Avoid duplicate URLs and crawler traps | `true` |
| `includePatterns` | Optional PCRE-compatible include filters | `[]` |
| `excludePatterns` | Optional PCRE-compatible exclude filters | `[]` |

Example:

```json
{
  "startUrl": "https://example.com",
  "preset": "full",
  "singlePage": false,
  "device": "mobile",
  "maxVisitedUrls": 250,
  "maxDepth": 4,
  "requestsPerSecond": 5,
  "workers": 2,
  "timeoutSecs": 10,
  "removeQueryParameters": true,
  "excludePatterns": ["/logout", "/cart"]
}
```

### Output

The default dataset contains three record types:

- `summary`: overall and category scores plus crawl totals.
- `finding`: critical, warning, and notice messages.
- `url`: status, response time, size, and content type for each HTML page.

The default key-value store contains:

- `REPORT`: compact JSON summary.
- `REPORT_HTML`: interactive SiteOne report.
- `REPORT_JSON`: complete SiteOne JSON report.

If a pay-per-event budget covers only part of the audited pages, the Actor
returns the paid page rows and summary, but withholds complete report files.

### Recommended pay-per-event pricing

Configure these events in **Publication → Monetization**:

| Event | Suggested price | Trigger |
| --- | ---: | --- |
| `audit-start` | `$0.20` | Once before SiteOne starts |
| `audited-page` | `$0.002` | Each HTML page or redirect added to the dataset |

Start with **pay per event + platform usage** until real run costs are measured.
After measuring at least 30 representative runs, include platform usage in the
event prices for clearer customer pricing.

### Safety and responsible use

- The Actor respects `robots.txt`; there is no option to disable it.
- Request rate and concurrency have conservative hard limits.
- Localhost, private networks, link-local addresses, reserved IPs, credentials
  in URLs, and non-standard ports are blocked.
- Redirect targets receive the same safety validation.
- Only audit websites you own or are authorized to test.
- Do not use high request rates against third-party websites.

The target website can change after DNS validation. Apify network isolation and
platform security controls remain part of the overall defense; no application
layer SSRF defense should be treated as absolute.

### Local development

Requirements:

- Node.js 22+
- A SiteOne Crawler 2.5.1 binary
- Docker for the production-equivalent build

Install and run tests:

```bash
npm install
npm run check
```

Run with a local SiteOne binary:

```bash
SITEONE_BINARY=/absolute/path/to/siteone-crawler npm start
```

Build and run the container:

```bash
docker build --tag siteone-website-audit .
docker run --rm \
  --volume "$PWD/storage:/usr/src/app/storage" \
  siteone-website-audit
```

### Publishing checklist

1. Create an Actor in Apify Console.
2. Push this repository using Apify CLI or connect a Git repository.
3. Build and run the example input.
4. Configure `audit-start` and `audited-page` PPE events.
5. Keep Actor permissions limited; the Actor needs no access to user resources
   beyond its default dataset and key-value store.
6. Add a Store icon, screenshots of the HTML report, support email, and SEO copy.
7. Test at 256 MB, 512 MB, and 1 GB; use the smallest reliable default.
8. Publish only after at least 10 websites pass and failure cases are documented.

Ready-to-edit Store copy, keywords, launch examples, and pricing projections
are available in [STORE\_LISTING.md](STORE_LISTING.md).

### Attribution

SiteOne Crawler is created by Ján Regeš and licensed under MIT. This wrapper is
an independent project and is not an official SiteOne product. See
[THIRD\_PARTY\_NOTICES.md](THIRD_PARTY_NOTICES.md).

# Actor input Schema

## `startUrl` (type: `string`):

The public website to audit.

## `preset` (type: `string`):

Controls which sections are emphasized in the HTML report. All core analyzers still run.

## `singlePage` (type: `boolean`):

Do not follow links to other pages on the same website.

## `device` (type: `string`):

Select the desktop, mobile, or tablet user agent used during the audit.

## `maxVisitedUrls` (type: `integer`):

Maximum number of pages and assets SiteOne may fetch.

## `maxDepth` (type: `integer`):

0 means unlimited depth within the URL limit.

## `requestsPerSecond` (type: `number`):

Global request rate. Keep this low unless you own the target website.

## `workers` (type: `integer`):

Maximum concurrent requests.

## `timeoutSecs` (type: `integer`):

Per-request timeout.

## `removeQueryParameters` (type: `boolean`):

Avoid duplicate crawl URLs and crawler traps caused by tracking parameters.

## `includePatterns` (type: `array`):

Only discovered URLs matching at least one pattern are included.

## `excludePatterns` (type: `array`):

Discovered URLs matching any pattern are skipped.

## Actor input object example

```json
{
  "startUrl": "https://example.com",
  "preset": "full",
  "singlePage": false,
  "device": "desktop",
  "maxVisitedUrls": 100,
  "maxDepth": 0,
  "requestsPerSecond": 5,
  "workers": 2,
  "timeoutSecs": 10,
  "removeQueryParameters": true,
  "includePatterns": [],
  "excludePatterns": []
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `htmlReport` (type: `string`):

No description

## `jsonReport` (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 = {
    "startUrl": "https://example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hamzamihaidaniel/siteone-website-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 = { "startUrl": "https://example.com" }

# Run the Actor and wait for it to finish
run = client.actor("hamzamihaidaniel/siteone-website-audit").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://example.com"
}' |
apify call hamzamihaidaniel/siteone-website-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hamzamihaidaniel/siteone-website-audit",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/AH60b44WK7fn0agD6/builds/kasuUKLB4mNqxOed1/openapi.json