# Local SEO Audit for Small Businesses (AI Agent Ready) (`hereditary_model/local-seo-audit`) Actor

Runs a local SEO audit on any business website: on page SEO, technical health, NAP consistency, LocalBusiness schema. Returns 0 to 100 scores and a fix list an AI agent can act on. About $0.70 per 10 page audit.

- **URL**: https://apify.com/hereditary\_model/local-seo-audit.md
- **Developed by:** [Aaron Marxsen](https://apify.com/hereditary_model) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Local SEO Audit Tool for Small Businesses

Run a local SEO audit on any business website and get 0 to 100 category scores plus a prioritized fix list specific enough for a human or an AI agent to act on, for about $0.70 per audit.

Here is real output from a live run (summary item, truncated):

```json
{
  "type": "summary",
  "scores": { "overall": 48, "onPage": 70, "technical": 65, "local": 0 },
  "pagesAudited": 3,
  "fixList": [
    {
      "severity": "high",
      "page": "site-wide",
      "issue": "No phone number detected on any audited page",
      "recommendation": "Add the business phone number in the site header or footer as a clickable tel: link, matching the Google Business Profile exactly."
    },
    {
      "severity": "high",
      "page": "site-wide",
      "issue": "No LocalBusiness schema.org markup found",
      "recommendation": "Add JSON-LD LocalBusiness markup to the home page with name, address, telephone, geo, url, openingHoursSpecification."
    }
  ]
}
```

One dataset item per audited page, plus one `summary` item with the scores and the full fix list.

### What can you do with it

Phrased the way people actually search for it:

- Automated local SEO audit for agencies, one run per client per month
- Audit a prospect's website before a sales call to show quick wins
- Check a business site for NAP consistency and LocalBusiness schema
- Qualify and prioritize a list of small business leads by SEO health
- Give an AI marketing agent a tool that audits websites on demand
- White label local SEO reports for freelancer client work

### What it checks

- On page SEO: titles, meta descriptions, H1s, image alt text, internal links
- Technical health: HTTPS, robots.txt, sitemap, mobile viewport, load time, page weight (browser rendered, not just raw HTML)
- Local signals: NAP consistency, LocalBusiness schema, map embed, city and service keywords

### Input, in plain language

You give it one website URL. Business name and city sharpen the local checks but are optional.

| Field | What it does |
| --- | --- |
| `websiteUrl` | The business website to audit. Required, everything else has safe defaults. |
| `businessName` | Optional. Exact name from the Google Business Profile, used for consistency checks. |
| `city` | Optional. City and state the business serves, used for local keyword checks. |
| `maxPages` | Hard cap on pages audited, and therefore on cost. Default 10, maximum 50. |

Minimal working example, this exact input produced the sample above:

```json
{ "websiteUrl": "https://books.toscrape.com", "maxPages": 3 }
```

### Integrations

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/hereditary_model~local-seo-audit/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "websiteUrl": "https://example.com", "businessName": "Smith Family Plumbing", "city": "Asheville, NC" }'
```

**Python (Apify client)**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("hereditary_model/local-seo-audit").call(
    run_input={"websiteUrl": "https://example.com", "city": "Asheville, NC"}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
summary = next(i for i in items if i["type"] == "summary")
```

**LangGraph / LangChain**

```python
from langchain_apify import ApifyActorsTool

local_seo_audit = ApifyActorsTool("hereditary_model/local-seo-audit")
## Add to your agent's tool list; the agent supplies websiteUrl itself.
```

**CrewAI**

```python
from crewai_tools import ApifyActorsTool

tool = ApifyActorsTool(actor_name="hereditary_model/local-seo-audit")
```

**n8n and Make**

Use the Apify integration (n8n: the Apify community node, Make: the Apify app), pick "Run Actor", select `hereditary_model/local-seo-audit`, and route the `summary` item to the next step. Typical flow: new row in a leads sheet, run audit, send the fix list to email or Slack.

**MCP**

Callable through the [Apify MCP server](https://mcp.apify.com) from Claude, Cursor, or any MCP client. Ask your agent to use the tool `hereditary_model/local-seo-audit`.

### Built for autonomous agents

Designed for autonomous agent workflows: predictable per event pricing, schema safe defaults, no required secrets, and a machine readable fix list (severity, page, issue, recommendation) an agent can turn into tickets or client emails. Supports agentic payments via x402 (USDC on Base) and Skyfire, so an agent can discover, pay for, and run it with no API key and no human signup.

### Pricing, the whole truth

Three events, platform usage bundled in, so the listed numbers are the full cost:

| Event | When | Price |
| --- | --- | --- |
| `audit-init` | Once, when the audit starts | $0.10 |
| `page-audited` | Per page actually analyzed | $0.02 |
| `report-generated` | Once, when the scored report is produced | $0.40 |

A typical 10 page audit: $0.10 + 10 x $0.02 + $0.40 = **$0.70**. A quick 3 page check: $0.56. The 50 page maximum: $1.50. `maxPages` is your hard budget cap, and only completed work is charged.

### FAQ

**What is a local SEO audit?**
A check of how well a business website is set up to rank in local search, covering on page content, technical health, and local signals like NAP consistency and LocalBusiness schema.

**What does the fix list contain?**
Prioritized issues, each with a severity, the page it is on, the problem, and a specific recommendation, in a JSON structure an agent or a script can act on directly.

**How is this different from a free online SEO checker?**
Browser rendered technical checks, local signals most tools skip (NAP, LocalBusiness schema, map embed, city keywords), structured output you can pipe anywhere, and scheduling built in.

**How much does one audit cost?**
About $0.70 for a typical 10 page audit. Cost is capped by `maxPages` and only analyzed pages are charged.

**Can an AI agent run this automatically?**
Yes. It works through the Apify MCP server and supports agentic payments (x402 and Skyfire), so a marketing agent can audit sites and pay per audit without a human in the loop.

### Related actors

Part of a connected toolkit. Chain these in your agent workflows:

- [Domain Intelligence API](https://apify.com/hereditary_model/domain-intelligence)
- [Website to Markdown for RAG and LLMs](https://apify.com/hereditary_model/website-to-markdown)
- [Broken Link Checker](https://apify.com/hereditary_model/broken-link-checker)
- [Contact Details Extractor](https://apify.com/hereditary_model/contact-details-extractor)
- [ATS Job Postings Scraper](https://apify.com/hereditary_model/ats-job-postings-scraper)
- [NPI Healthcare Provider Directory](https://apify.com/hereditary_model/healthcare-provider-directory)
- [Bandcamp Discography Scraper](https://apify.com/hereditary_model/bandcamp-discography-scraper)

# Actor input Schema

## `websiteUrl` (type: `string`):

Full URL of the business website to audit, including protocol. Example: https://example-plumber.com

## `businessName` (type: `string`):

Exact business name as it appears on the Google Business Profile. Used to check name consistency across pages. Example: Smith Family Plumbing

## `city` (type: `string`):

City and state or region the business serves. Used to check for local keywords in titles and headings. Example: Asheville, NC

## `maxPages` (type: `integer`):

Upper bound on internal pages crawled and analyzed. Each analyzed page is one page-audited charge, so this caps your cost. Default 10, maximum 50.

## Actor input object example

```json
{
  "websiteUrl": "https://books.toscrape.com",
  "maxPages": 10
}
```

# 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 = {
    "websiteUrl": "https://books.toscrape.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hereditary_model/local-seo-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 = { "websiteUrl": "https://books.toscrape.com" }

# Run the Actor and wait for it to finish
run = client.actor("hereditary_model/local-seo-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 '{
  "websiteUrl": "https://books.toscrape.com"
}' |
apify call hereditary_model/local-seo-audit --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/XDtw3V0vffwdr6C21/builds/khzNUREjfihzP0TQK/openapi.json