# Website Accessibility & SEO Auditor (`umararshad2/my-actor-2`) Actor

Rendered website accessibility and SEO audit for public pages. Find WCAG 2.0 A/AA issues, selectors, remediation links, titles, meta descriptions, H1s, canonicals, alt text, robots, internal links, JSON-LD, scores, and a prioritized summary. Automated QA aid—not compliance certification.

- **URL**: https://apify.com/umararshad2/my-actor-2.md
- **Developed by:** [Umar Arshad](https://apify.com/umararshad2) (community)
- **Categories:**
- **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 audit completeds

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?

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

Audit rendered webpages for WCAG accessibility defects and practical on-page SEO problems in one bounded crawl. The Actor returns page-level evidence that developers, agencies, and QA teams can export to JSON, CSV, Excel, or an API workflow.

### What this website auditor checks

- WCAG 2.0 A and AA rules with axe-core against the rendered page
- affected CSS selectors, impact levels, failure summaries, and remediation links
- titles, meta descriptions, H1 usage, canonical links, image alt attributes, robots metadata, internal links, and JSON-LD presence
- accessibility and SEO scores, plus a prioritized cross-page issue summary
- optional full-page screenshots stored with stable collision-resistant keys

### Best use cases

- pre-release accessibility QA for public landing pages
- agency website audits and technical prospect qualification
- recurring website quality checks with Apify Schedules
- structured issue exports for dashboards, spreadsheets, and engineering backlogs
- small JavaScript-rendered site crawls where raw HTML checks miss page content

### Quick start

1. Add one or more public webpage URLs.
2. Start with one page and crawl depth zero.
3. Increase the page cap only after reviewing the first result.
4. Export the default dataset or connect it to your workflow.

Example input:

```json
{
  "startUrls": [{ "url": "https://example.com" }],
  "maxPagesPerSite": 1,
  "maxDepth": 0,
  "respectRobotsTxt": true,
  "includeScreenshots": false
}
```

### Input limits and cost control

`startUrls` accepts up to 10 public HTTP(S) URLs. `maxPagesPerSite` is capped at 50 and is the maximum number of billable successful page-audit results per starting site. `maxDepth` is capped at 5. The Actor respects `robots.txt` by default.

The live Pricing tab is authoritative. Under pay-per-event pricing, a successful saved page result is the `page-audited` event; invalid input, blocked private destinations, and failed page audits are not charged as page-audited events. User charge limits are respected and stop the crawl cleanly.

### Output

Each successful dataset item contains the audited URL, title, timestamp, accessibility and SEO scores, issue count, issue details, link counts, and optional screenshot key. Failed page requests are preserved as uncharged diagnostic rows. The `OUTPUT` key-value record contains audited and failed page counts, average scores, total issues, and the most common issue IDs.

### Security and responsible use

Only anonymously reachable public HTTP(S) pages are supported. The Actor rejects credential-bearing URLs, local hostnames, private/link-local/reserved IP destinations, and unsafe redirect or subresource requests. It does not accept cookies, passwords, or authenticated sessions and does not bypass CAPTCHAs or access controls.

Audit only websites you are authorized to test. This Actor is an automated QA aid, not a legal certification of WCAG, ADA, EAA, Section 508, or other compliance. Automated checks cannot replace expert manual review.

### Reliability and known scope

One page failure does not erase successful results from the same run. The crawler is intentionally bounded and follows same-origin links only. Scores are product heuristics, not Google rankings or legal compliance scores. This release does not compare two runs automatically and does not generate PDF or SARIF reports.

### Support

For bugs or feature requests, use the Actor's Issues tab and include the public test URL, run ID, and expected behavior. Do not include passwords, private URLs, or personal data.

# Actor input Schema

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

Public HTTP(S) pages to audit.

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

Maximum pages audited per site.

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

Zero audits only submitted URLs.

## `respectRobotsTxt` (type: `boolean`):

Respect crawler exclusions.

## `includeScreenshots` (type: `boolean`):

Save page screenshots.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "maxPagesPerSite": 1,
  "maxDepth": 0,
  "respectRobotsTxt": true,
  "includeScreenshots": false
}
```

# Actor output Schema

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

Audited page records in the default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("umararshad2/my-actor-2").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 = { "startUrls": [{ "url": "https://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("umararshad2/my-actor-2").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 '{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}' |
apify call umararshad2/my-actor-2 --silent --output-dataset

```

## MCP server setup

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

```

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/PF0rtCVyP1eDDPfyM/builds/BhifbAye9HJcEGKUK/openapi.json