# Website Health Audit: Speed, SEO & Accessibility (`planetlinux98/website-health-audit`) Actor
Lighthouse speed, SEO and best-practice scores plus a plain-language accessibility check for any web page, with a prioritized fix list, Core Web Vitals and the manual checks to do next. Built for agencies and site owners. Never claims compliance.
- **URL**: https://apify.com/planetlinux98/website-health-audit.md
- **Developed by:** [Elliott Tyson](https://apify.com/planetlinux98) (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 $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 Health Audit** checks any web page for **speed, SEO, best practices and accessibility**, and explains the results in plain language. You get a short prioritized list of what to fix and why it matters to real people. It runs Google's **Lighthouse** (the same engine behind PageSpeed Insights) on each page, then turns the technical output into something a busy site owner, marketer or client can act on.
It's built for agencies and freelancers doing client audits, site owners checking their own pages, and AI tools that need a quick, reliable read on a page's health.
> **This is not a compliance check.** Automated tools can only find some accessibility problems. Each result includes the manual checks to do next (keyboard, screen reader, zoom). For a full assessment, test with people who use assistive technology, or consider a review by an accessibility specialist.
### What can this website audit do?
- **Speed and Core Web Vitals:** a Lighthouse performance score plus lab measurements (Largest Contentful Paint, Total Blocking Time, Cumulative Layout Shift and more). Speed improvements are ranked by estimated time saved.
- **Accessibility, in plain language:** each problem automated checks find comes with:
- why it matters;
- how to fix it;
- the related WCAG success criterion;
- how many elements are affected, with examples you can hand to a developer.
- **A manual checklist:** keyboard order, focus, screen reader and zoom checks that no automated tool can do for you.
- **SEO basics:** indexability, titles, meta descriptions, link text, robots.txt, canonical links and more.
- **Best practices:** HTTPS, browser errors, image quality, permission pop-ups and similar issues.
- **AI agent readiness:** Lighthouse's new agentic-browsing score (how well AI agents can read and use the page).
- **Top 10 fixes** across all areas, highest priority first.
- **The full Lighthouse report** (optional), saved as an HTML file you can send to a developer.
- **Mobile, desktop or both:** mobile simulates a mid-range phone on a slower connection, like PageSpeed Insights.
### How to audit a website
1. Click **Try for free** (you'll need a free Apify account).
2. Add the pages to audit, one per line. Start with the pages that matter most: home, contact, and your main product or service page.
3. Choose **Mobile**, **Desktop** or **Both**, and whether to save the full Lighthouse report.
4. Click **Start**. Each page takes about 15 to 30 seconds.
5. Read the **Overview** and **Top fixes** tabs, or download everything as JSON, CSV or Excel. You can also schedule monthly audits and connect them to Google Sheets, Slack, Make or Zapier.
### Input example
```json
{
"urls": ["https://www.example.com/", "https://www.example.com/contact"],
"device": "mobile",
"saveHtmlReport": true
}
```
### Output example
One result as JSON:
```json
{
"url": "https://www.toronto.ca/",
"device": "mobile",
"performanceScore": 67,
"accessibilityScore": 95,
"bestPracticesScore": 92,
"seoScore": 92,
"agentReadinessScore": 88,
"largestContentfulPaintMs": 7100,
"summary": "Speed: needs work (67/100). The main content takes about 7.1 seconds to appear on a mid-range phone. Accessibility (automated checks only): good (95/100), with 2 kinds of problem found, for example \"some buttons and links are too small or too close together\". Search engine basics: good (92/100). Automated checks only catch some accessibility problems, so 13 quick manual checks are listed too.",
"topFixes": [
{
"check": "target-size",
"area": "Accessibility",
"title": "Some buttons and links are too small or too close together",
"whyItMatters": "People with limited dexterity or tremors, and anyone on a phone, tap the wrong thing.",
"howToFix": "Make touch targets at least 24 by 24 CSS pixels, or leave enough space around them.",
"wcag": "2.5.8 Target Size (Minimum) (AA, WCAG 2.2)",
"priority": "medium",
"affected": 3,
"examples": ["div > div.container-fluid > p > a"],
"estimatedSavingsMs": null
}
],
"manualChecks": [
{ "title": "Keyboard order makes sense", "whatToDo": "Press Tab repeatedly from the top of the page. Focus should move in a logical order that matches the layout." }
],
"disclaimer": "This is an automated check, not an accessibility audit or a statement of compliance..."
}
```
The example is shortened. Each row also includes `accessibilityIssues`, `seoIssues`, `bestPracticeIssues`, `speedImprovements` and, if you asked for it, `htmlReportUrl`.
### How much does a website audit cost?
You pay **$0.01 per page audit**, plus a tiny start fee. Choosing **Both** devices counts as two audits per page. You aren't charged for pages that couldn't be audited.
- 10 pages on mobile: about $0.10
- A 50-page site on mobile and desktop: about $1.00
Apify's free plan includes $5 of monthly credit, which covers about 500 page audits. To cap any single run, set a maximum cost when you start it.
### Good to know
- **Scores vary a little between runs.** Lighthouse measures in a simulated environment, so expect a few points of difference, just like PageSpeed Insights.
- **One page at a time.** Each page is audited separately, so a long list takes a while (roughly 2 to 4 pages a minute).
- **Very long lists:** a run stops by itself a couple of minutes before its time limit (one hour by default), so it still finishes successfully. You're only charged for pages audited, and the pages not reached are listed under `notAudited` in RUN_SUMMARY. For big lists, raise the run's timeout or split the list.
- **robots.txt is respected.** If a site asks automated tools not to load a page, it's skipped. If it's your own site, you can allow `WebsiteHealthAudit` in your robots.txt.
- **Logins and pages behind forms can't be audited.** Only public pages are checked.
- **No personal data is collected.** Examples only include the element's location in the page (a CSS selector), never its text.
### FAQ
#### Does a 100 accessibility score mean my site is accessible?
No. The score only reflects automated checks, which can only spot some kinds of problem. A page can score 100 and still be hard or impossible to use with a keyboard or screen reader. Use the `manualChecks` list, and test with real assistive technology users if you can.
#### Is this the same as Google PageSpeed Insights?
It uses the same Lighthouse engine and mobile settings, so scores are comparable. Differences come from network and timing. PageSpeed Insights also shows real-visitor data from Chrome (the Chrome UX Report); this tool shows lab data only.
#### Which accessibility rules are checked?
Lighthouse's accessibility checks are powered by axe-core and cover things like text alternatives, form labels, contrast, page language, headings, landmarks, ARIA and touch-target size. Each problem includes the related WCAG 2.2 success criterion, or "best practice" when it isn't a WCAG requirement.
#### Can I use it through the API or with AI agents?
Yes. Start audits and read results through the Apify API (JavaScript and Python clients are available), call it from AI agents through Apify's MCP server, or schedule it and send results to Google Sheets, Slack, Make or Zapier.
#### Something's wrong or unclear?
Please open an issue on the **Issues** tab with the page address and what you expected.
# Actor input Schema
## `urls` (type: `array`):
One page per line, for example https://www.example.com/ or example.com/contact. Each page is audited separately, so include the pages that matter most (home, contact, a key product or service page).
## `device` (type: `string`):
Mobile simulates a mid-range phone on a slower connection, the same way Google PageSpeed Insights does. "Both" runs two audits per page and costs twice as much.
## `saveHtmlReport` (type: `boolean`):
Also save the full, technical Lighthouse HTML report for each page and include a link to it (htmlReportUrl). Handy for sending to a developer.
## `maxPages` (type: `integer`):
Only audit the first this-many pages from your list. 0 means no limit.
## Actor input object example
```json
{
"urls": [
"https://www.w3.org/WAI/"
],
"device": "mobile",
"saveHtmlReport": false,
"maxPages": 0
}
```
# Actor output Schema
## `results` (type: `string`):
Scores, plain-language fixes and manual checks for each page.
## `summary` (type: `string`):
How many pages were audited, and any that could not be.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"urls": [
"https://www.w3.org/WAI/"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("planetlinux98/website-health-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "urls": ["https://www.w3.org/WAI/"] }
# Run the Actor and wait for it to finish
run = client.actor("planetlinux98/website-health-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 '{
"urls": [
"https://www.w3.org/WAI/"
]
}' |
apify call planetlinux98/website-health-audit --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,planetlinux98/website-health-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 ` 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/jh1zSGFCbiZdD0XbO/builds/YWeikHQ9wwoBMDfUp/openapi.json