SEO Audit Tool - Technical SEO Audit for Any List of URLs

This SEO audit tool runs a technical SEO audit on every URL you give it and tells you, in plain language, what is wrong with each page. Not a wall of raw tags: a score out of 100 and a list of findings, each one graded by how much it actually costs you. Use it to check a client site before a pitch, monitor your own pages after a release, or audit hundreds of competitor URLs in bulk.

Most SEO tools give you a dashboard and leave the interpretation to you. This one does the interpretation. Every finding says what is wrong, why it matters, and what the number is. "The title is 75 characters; past about 60 it gets truncated in results." You can act on that without knowing what a canonical tag is.

What the SEO audit tool checks

Whether the page can be indexed at all. This comes first, because everything else is decorative if the answer is no. Three separate switches can keep a page out of a search index and the Actor checks all three: a noindex in the robots meta tag, the same directive arriving as an X-Robots-Tag response header, and a canonical tag pointing at a different URL. The header case is the one people miss, because it is invisible when you view source.

The tags that decide how you appear in results. Title and meta description with their lengths measured against the point where search engines cut them off. Canonical URL, resolved to absolute and compared properly, so a canonical of https://example.com on the page served at https://example.com/ is correctly read as the same address rather than reported as a conflict.

Structure. Heading counts by level, the text of every H1, and whether the outline skips a level. Word count taken from visible prose only, with scripts and styles excluded, plus the text-to-HTML ratio.

Structured data. Every JSON-LD block is parsed and its schema.org types listed. Blocks that fail to parse are reported individually with the line the JSON breaks on. Broken structured data is invisible on the page and silently costs you rich results, so it is worth catching.

Images and links. Images with no alt attribute are counted separately from images with a deliberately empty one, because an empty alt is correct for decoration and flagging it would be wrong. Images with no declared width and height are counted too, since those cause the layout to jump while a page loads. Links are split into internal and external, with nofollow counted and empty anchors flagged.

The full redirect chain. Every hop is recorded with its status code and where it points. A page reached through three redirects wastes crawl budget, and you cannot see that from the final URL alone.

Security headers. Six standard protective headers, each reported present or missing, with a count.

robots.txt, sitemaps and llms.txt. Whether robots.txt exists, how many rules it carries, which sitemaps it declares, and whether those sitemaps actually resolve to real URLs. A sitemap is only counted when the response carries a real sitemap root element, so a site that answers unknown paths with its ordinary page shell is not credited with a sitemap it does not have.

Which crawlers your robots.txt lets in. Search crawlers and AI crawlers are reported separately, because they are separate decisions. A site can be perfectly open to search and closed to model training, and that is usually deliberate rather than a mistake, so it is reported as something to know rather than as a defect. Blocking search crawlers, by contrast, is treated as critical. The allow-or-deny answer comes from the same rule matching a real crawler uses, including group selection and wildcards, rather than from reading the Disallow lines and hoping.

The certificate. Issuer, protocol version, cipher, expiry date, days remaining, and whether the certificate actually covers the hostname you asked for. An invalid or mismatched certificate is critical; one expiring within a month is a warning.

DNS. A, AAAA, MX, NS, TXT and CNAME records, plus whether the domain publishes SPF and DMARC. Missing SPF or DMARC makes your domain easier to spoof, which is worth knowing even when you came here for search rankings. A lookup that never answered is reported apart from one that answered empty, so "no records" never gets confused with "we could not ask".

Scoring

Each page starts at 100 and loses weight for every finding: 15 for a critical, 5 for a warning, 1 for a notice. Results are sorted worst first, so the page that needs attention is the first row you see.

The three severities mean three different things:

• critical stops the page being indexed or served at all
• warning costs you ranking or clicks
• notice is worth knowing but is not a defect

How to use the SEO audit tool

1. Paste the pages you want to audit into URLs or domains. A bare domain such as example.com works and is audited as its homepage.
2. Optionally lower Maximum pages, change Pages in parallel, or pick a Request from country when the site serves different content by region.
3. Start the run. Results appear in the dataset, worst page first, and the run summary sits in the key-value store under summary.

The same input works through the Apify API, so the audit can run on a schedule or from your own code as a simple SEO audit API.

Input

Give it a list of URLs. A bare domain such as example.com is accepted and audited as its homepage. You can also set how many pages to fetch at once, how many times to retry, and optionally which country to request from when a site serves different content by region.

Field	Type	Default	What it does
urls	array of strings	(required)	Pages or domains to audit
limit	integer, 1-500	50	How many pages to audit in one run
concurrency	integer, 1-20	5	How many pages to fetch at the same time
retries	integer, 1-8	3	Retries before a page is reported as unreachable
country	string	empty	Two-letter country code to request the pages from, such as us or de

Example input:

{
  "urls": ["apify.com", "https://www.python.org/"],
  "limit": 50,
  "concurrency": 5,
  "retries": 3
}

Auditing many pages of one site is much cheaper than auditing many sites. robots.txt, the sitemaps, DNS and the certificate belong to the site rather than the page, so they are looked up once and shared across every page on that origin. In practice fifty pages of one site cost fifty page requests plus one set of site lookups.

Output

One row per page, containing every fact listed above plus:

• score, and counts of critical, warning and notice findings
• findings, each with a severity, a stable code and a readable message
• internal_urls, the internal links found on the page, which you can feed straight back in as the input for a wider audit

A page that could not be fetched is still a row. It carries the error and a critical finding rather than quietly disappearing from the results, because a missing row is the one thing an audit must never produce.

The run summary holds the counts, the average score and the totals by severity.

Example SEO audit row

A real row from auditing https://www.python.org/. For readability it shows a selection of the fields, the first four of ten findings and the first three of 64 internal URLs; the full row also carries the raw security headers, Open Graph and Twitter tags, per-crawler robots.txt answers, sitemap details, certificate details and every DNS record.

{
  "url": "https://www.python.org/",
  "final_url": "https://www.python.org/",
  "status": 200,
  "score": 70,
  "issues_critical": 0,
  "issues_warning": 5,
  "issues_notice": 5,
  "response_time_ms": 1204,
  "title": "Welcome to Python.org",
  "title_length": 21,
  "meta_description": "The official home of the Python Programming Language",
  "meta_description_length": 52,
  "canonical": null,
  "canonical_is_self": null,
  "indexable": true,
  "indexable_blockers": [],
  "h1_count": 5,
  "heading_counts": {
    "h1": 5,
    "h2": 9
  },
  "word_count": 903,
  "schema_types": [
    "WebSite"
  ],
  "images_total": 1,
  "images_missing_dimensions": 1,
  "links_internal_unique": 64,
  "links_external_unique": 64,
  "security_headers_missing": [
    "x-content-type-options",
    "content-security-policy",
    "referrer-policy",
    "permissions-policy"
  ],
  "security_headers_score": 2,
  "robots_txt_present": true,
  "robots_txt_disallow_rules": 6,
  "ai_crawlers_blocked": [],
  "search_crawlers_blocked": [],
  "llms_txt_present": false,
  "sitemap_found": false,
  "tls_valid": true,
  "tls_protocol": "TLSv1.3",
  "tls_issuer": "GlobalSign nv-sa",
  "tls_days_remaining": 132,
  "tls_covers_host": true,
  "dns_has_spf": false,
  "dns_has_dmarc": false,
  "findings": [
    {
      "severity": "warning",
      "code": "title_short",
      "message": "The title is only 21 characters, which wastes available space."
    },
    {
      "severity": "notice",
      "code": "description_short",
      "message": "The meta description is only 52 characters."
    },
    {
      "severity": "notice",
      "code": "h1_multiple",
      "message": "The page has 5 H1 headings; one is the usual convention."
    },
    {
      "severity": "warning",
      "code": "canonical_missing",
      "message": "No canonical URL is declared, so duplicate versions of this page can compete with each other."
    }
  ],
  "position": 1,
  "internal_urls": [
    "https://www.python.org/",
    "https://www.python.org/about/",
    "https://www.python.org/about/apps"
  ]
}

You can export the dataset as JSON, CSV, Excel or HTML, or read it through the API.

Use cases

• Agency pitches and onboarding. Audit a prospect's key pages in one run and open the meeting with a ranked list of concrete problems.
• Release checks. Run the audit after every deploy and catch a stray noindex, a broken canonical or an expiring certificate before search engines do.
• Bulk SEO audit of a whole site. Feed internal_urls from the homepage back in as input to audit every page linked from it.
• Competitor research. Compare scores, structured data and AI crawler policies across competitor homepages side by side.
• Data pipelines. Push rows into a spreadsheet, BI tool or your own database and track the score of each page over time.

How this compares to other SEO audit tools

	This Actor	Desktop crawlers	SaaS site audit suites
Setup	Paste URLs, run	Install and configure	Account and project per site
Bulk lists of unrelated sites	Yes	Awkward	One project per site
Plain-language findings with severity	Yes	Raw columns	Yes
robots.txt, AI crawlers, llms.txt, SSL and DNS in the same row	Yes	Partly	Partly
API and scheduling	Built in	No	Paid tiers
Pricing	Per page audited	Licence per seat	Monthly subscription

Desktop crawlers and full SaaS suites go deeper on one site, with JavaScript rendering and historic tracking. This Actor is built for fast, repeatable technical checks across any list of URLs, with results you can feed straight into your own tools.

Pricing and free users

The price remains $0.002 per run plus $0.01 per delivered audited page. The run fee also applies when the input contains no usable URL. An unreachable page still produces an audit row and counts as one audited page, because reporting that failure is part of the audit. No page fee is charged when no rows are delivered.

Users without a paid Apify plan receive up to ten rows per run. The Actor audits the requested pages, sorts them by score, and delivers the ten pages with the lowest scores. The summary continues to describe the complete audit before this delivery limit.

Large audits continue automatically between requests. Keep the same URL list and options for one run; the Actor handles continuation and writes the final rows to the default dataset.

FAQ

Does the SEO audit tool render JavaScript? No. Only what the server sends is inspected. Content that a page builds in the browser after loading is not part of the audit, so a fully client-rendered page will honestly report the small shell that was actually served. That is usually the finding rather than a limitation: it is also what a search engine sees on its first pass.

Is a 404 retried? No. Retries apply only to timeouts and server errors. A 404 is an answer, and it is reported as one.

Can it audit a whole website, not just one page? Yes. Every row lists the page's internal_urls. Run the homepage first, then feed those URLs back in as input. Pages on the same site share one set of robots.txt, sitemap, DNS and certificate lookups.

What happens when a site is down or blocks the request? The run still succeeds. The page gets a row with fetch_error and a critical unreachable finding, so you see the failure instead of a missing result.

Why is blocking AI crawlers not marked as a problem? Being open to search and closed to model training is usually a deliberate choice, so it is reported as a notice. Blocking search crawlers is treated as critical.

Can I use it as an SEO audit API? Yes. Start a run through the Apify API with the same JSON input and read the dataset items when it finishes, or call it from Make, Zapier or n8n.