# Website AI Readiness Audit: Visitor Experience + AI Search (`islandata/website-ai-readiness-audit`) Actor

Scored AI-readiness report per website, in plain English. Checks whether visitors can get answers (chat/FAQ), find contact and pricing, plus speed, SEO, and AI search visibility (GPTBot/ClaudeBot access, llms.txt, Schema.org). For agencies and site owners.

- **URL**: https://apify.com/islandata/website-ai-readiness-audit.md
- **Developed by:** [Radu Coman](https://apify.com/islandata) (community)
- **Categories:** AI, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$500.00 / 1,000 website 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 AI Readiness Audit: Visitor Experience + AI Search

**One scored, plain-English report per website: is it ready for visitors who arrive with questions, and for the AI search engines that answer them?**

Most "AI readiness" checkers test one thing: whether AI crawlers can technically read your site. This audit covers that too, but it starts from the question that actually costs you leads: **when a real visitor lands with a question, can they get an answer - or do they leave and ask ChatGPT instead?**

It is the only audit in this category that renders each site in a real browser, reads the actual page content with an AI (Google Gemini), and writes a verdict a business owner understands - not a JSON of checkmarks.

**$0.50 per audited website**, all checks included. You are not charged for Apify platform usage, and a site the Actor cannot reach costs you nothing.

![Sample audit report: score, plain-English summary and prioritized issues with fixes](https://raw.githubusercontent.com/raducoman/website-ai-readiness-audit-assets/main/01-report.png)

### Who it is for

- **Agencies and freelancers** - audit a prospect list before outreach. The report names concrete, fixable problems on each site, so it doubles as the conversation opener.
- **Site owners** - a second opinion on what a first-time visitor (and an AI crawler) actually experiences, in language you do not need a developer to translate.
- **SEO and GEO consultants** - visitor-experience findings plus the AI-search checks (crawler access, llms.txt, structured data) in one run.

### What it checks

**Visitor experience** (does the site serve a human with a question?)

- **Visitor guidance** - live-chat and assistant widgets (Intercom, Crisp, Tawk.to, HubSpot, Tidio, Zendesk and more), FAQ pages and sections. A site with neither leaves every question unanswered.
- **Findability** - how many clicks to reach contact information and pricing, or whether they are missing entirely.
- **Performance** - mobile performance score and Largest Contentful Paint via Google PageSpeed Insights.
- **Cookie consent** - whether a consent banner is present (relevant for EU audiences).

**AI search visibility** (can AI search engines read and cite the site?)

- **AI crawler access** - whether robots.txt blocks GPTBot, ClaudeBot, PerplexityBot, Google-Extended and other AI crawlers. A blocked crawler means the site cannot be cited by that AI product.
- **llms.txt** - presence of the emerging AI-guidance file.
- **Structured data** - Schema.org markup (JSON-LD or microdata) on the homepage.

**Fundamentals**

- **SEO basics** - title, meta description, H1 structure, canonical URL, Open Graph tags, robots.txt, sitemap.xml.
- **Technology** - CMS and framework detection (WordPress, Shopify, Wix, Webflow, Next.js and more), including legacy technology worth upgrading.

### How the report is produced

The Actor visits the homepage in a real browser (JavaScript rendered, like a visitor sees it), discovers and visits the key pages (contact, pricing, FAQ, about), and runs the checks above. An AI layer (Google Gemini) then reads the findings **and the actual page text** and produces a 0-100 readiness score, a 2-3 sentence summary in plain English, and a prioritized issue list - each issue with what was observed on *your* site and one actionable fix.

**Honesty guarantee:** the AI can only report issues that the deterministic checks actually observed. If the code did not find the problem, the report cannot claim it.

### Input

```json
{
    "websites": ["https://example.com", "https://another-site.com"],
    "maxPagesPerSite": 5,
    "runPerformanceCheck": true
}
```

- **websites** - one homepage URL per line. You are charged per successfully audited site; unreachable sites are skipped and not charged.
- **maxPagesPerSite** - the Actor visits the homepage plus key pages (contact, pricing, FAQ, about), up to this limit.
- **runPerformanceCheck** - PageSpeed adds up to a minute per site; disable it for faster runs.

### Output

One dataset item per audited site:

```json
{
    "url": "https://example.com/",
    "score": 58,
    "summary": "The site presents its services clearly, but a visitor with a question has no way to ask it...",
    "technology": ["WordPress", "Elementor"],
    "performance": { "score": 46, "lcpMs": 4900 },
    "issues": [
        {
            "type": "no_visitor_guidance",
            "severity": "high",
            "detail": "No chat, assistant or FAQ was found on any page. Pricing is 2 clicks deep.",
            "recommendation": "Add an AI concierge that answers visitor questions from your existing content."
        },
        {
            "type": "poor_ai_search_visibility",
            "severity": "medium",
            "detail": "robots.txt blocks GPTBot and PerplexityBot, and no Schema.org markup was found.",
            "recommendation": "Allow AI crawlers in robots.txt and add JSON-LD structured data to key pages."
        }
    ],
    "findings": { "...": "all raw measurements included" }
}
```

![Output contract: one JSON item per audited site, with the full raw findings](https://raw.githubusercontent.com/raducoman/website-ai-readiness-audit-assets/main/02-json.png)

The full deterministic findings are always included (guidance, findability depths, SEO, AI visibility, technology), so you can build your own filtering or scoring on top.

### Typical uses

- **Prospecting**: run 50 local businesses, sort by score ascending, contact the bottom 20 with their own report.
- **Pre-campaign check**: verify the site can convert a visitor with questions before paying for traffic to it.
- **Client reporting**: attach the plain-English summary to your monthly report; the raw findings back every claim.

### For AI agents and MCP users

This Actor is built to be called by AI agents (for example through the Apify MCP server). Typical requests it answers:

- "Audit this website and tell me what to fix."
- "Check whether example.com is ready for AI search. Is it blocking GPTBot or ClaudeBot?"
- "Is this site AI-ready? Can a visitor with a question get an answer there?"
- "Run a website audit on this lead before I write the outreach email."
- "Score these 10 websites and rank them by AI readiness."

Minimal input: `{ "websites": ["https://example.com"] }`. The output is one JSON item per site with a 0-100 `score`, a plain-English `summary` you can quote directly, an `issues` array (type, severity, what was observed, one recommended fix), and the full raw `findings`. Unreachable sites produce no item and are not charged. A typical audit takes 1-3 minutes per site; set `runPerformanceCheck` to `false` for faster runs.

### Automate it

The Actor works with Apify's official integrations, so a prospect list can be audited on a
schedule without writing code. In **Make**, **Zapier** or **n8n**, the whole flow is four
steps: read the websites from a Google Sheet, "Run an Actor" with
`{ "websites": ["<the sheet's website column>"] }`, fetch the run's dataset items, then send
each report by email. One row in, one plain-English report out.

### No vendor recommendations

The report never names or links a product. Recommendations describe what to fix, not what to buy - and an issue is only ever reported when the deterministic checks actually observed it on your site.

# Actor input Schema

## `websites` (type: `array`):

One website per line (homepage URL). You are charged per successfully audited site.

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

How many pages to examine per site (homepage + key pages such as contact, pricing, FAQ, about).

## `runPerformanceCheck` (type: `boolean`):

Measure mobile performance via Google PageSpeed Insights (adds up to a minute per site).

## Actor input object example

```json
{
  "websites": [
    "https://apify.com"
  ],
  "maxPagesPerSite": 5,
  "runPerformanceCheck": true
}
```

# Actor output Schema

## `results` (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 = {
    "websites": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("islandata/website-ai-readiness-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 = { "websites": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("islandata/website-ai-readiness-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 '{
  "websites": [
    "https://apify.com"
  ]
}' |
apify call islandata/website-ai-readiness-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,islandata/website-ai-readiness-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/IjIJHQxB7xHSAblRy/builds/De4J5jtCQCJ2EjlkR/openapi.json