The SEO Audit Stack I Actually Use in 2026 (Tools, Scripts, and What to Skip)

I run SEO audits in four layers: crawl and index health first, then on-page and content, then technical performance, then backlinks. Core tools are Screaming Frog and Google Search Console, both of which I check against each other because they disagree in useful ways.
Part of the complete SEO guide.
On this page
- Layer 1: Crawl and index health
- Layer 2: Log file analysis
- Layer 3: Core Web Vitals and real user data
- Layer 4: Content and AI Overview visibility
- Layer 5: Technical hygiene checks
- What I stopped using
- The order I actually run it
- FAQ
- Do I need paid tools to run a real SEO audit?
- How often should I run a full audit?
- Is INP really more important than page load speed now?
Most “SEO audit stack” posts are just affiliate lists. This is the stack I run on client sites in 2026, including the parts that are free, the parts that cost money, and the parts I stopped using because they lie to you. If you’re auditing your own site or a client’s, this is the order I’d run things in.
One thing up front: the stack matters less than the process. A $500/month tool suite won’t save a site with thin content and a broken internal linking structure. Tools find problems. They don’t fix them.
Layer 1: Crawl and index health
You need to know what Google can actually reach. Two tools here, and you want both because they disagree in useful ways.
- Screaming Frog (free up to 500 URLs, then about $260/year). Still the best desktop crawler. Fast, scriptable, and the custom extraction feature is worth the license by itself.
- Google Search Console. Free. The Pages report tells you what’s indexed vs. crawled-but-excluded. The URL Inspection tool tells you what Google actually rendered. That last part matters more than it used to.
What I’m looking for on the crawl: orphan pages, redirect chains longer than one hop, canonical tags that point somewhere unexpected, and noindex tags that snuck in from a staging push. That last one happens constantly. Someone copies a staging config to production and half the blog disappears from the index for three weeks.
Run the crawl with JavaScript rendering on for at least a sample. In 2026 a lot of sites are client-rendered and the raw HTML tells you nothing. If the rendered and non-rendered crawls look wildly different, you have a rendering problem, not a content problem.
Layer 2: Log file analysis
This is the layer most audits skip and it’s the one that catches the expensive stuff. Server logs tell you what Googlebot actually requested, how often, and what it wasted time on.
You don’t need a paid tool for this. A little Python and pandas gets you there. Here’s the shape of the script I run:
import pandas as pd
import re
# nginx combined log format, one line per request
pattern = re.compile(
r'(?P<ip>\S+) .* \[(?P<time>[^\]]+)\] '
r'"(?P<method>\S+) (?P<path>\S+)[^"]*" '
r'(?P<status>\d{3}) (?P<bytes>\d+)'
)
rows = []
with open("access.log", encoding="utf-8", errors="ignore") as f:
for line in f:
m = pattern.match(line)
if m and "Googlebot" in line:
rows.append(m.groupdict())
df = pd.DataFrame(rows)
df["time"] = pd.to_datetime(df["time"], format="%d/%b/%Y:%H:%M:%S %z")
# Where is Googlebot spending its crawl budget?
top = df["path"].value_counts().head(50)
print(top)
# How much of the crawl is hitting 4xx/5xx?
errors = df[df["status"].str.startswith(("4", "5"))]
print(errors["path"].value_counts().head(20))
What you’re looking for: Googlebot hammering URLs that return 404, crawling faceted navigation or filter parameters endlessly, or ignoring your new content entirely. If 40% of the crawl is on URLs you don’t care about, that’s your problem, and no amount of on-page tweaking fixes it.
Layer 3: Core Web Vitals and real user data
Lab data is a starting point. Field data is the truth. In 2026 the useful signals are still INP (Interaction to Next Paint, which replaced FID back in 2024), LCP, and CLS.
- PageSpeed Insights for the field data from the CrUX report. Free.
- web-vitals JavaScript library if you want your own RUM data instead of Google’s sampled version.
- Chrome DevTools Performance panel for finding the actual long task causing a bad INP.
INP is the one that gets people. It’s not about your page load, it’s about what happens when someone taps a button and the main thread is busy. A 200ms handler that triggers a 400ms re-render is a failing INP. Common causes: heavy third-party scripts (chat widgets, tag managers), synchronous layout reads in event handlers, and hydration on large React trees.
If you’re on WordPress, the usual suspects are plugin bloat and unoptimized images. If you have something custom built, the fix is often architectural and that’s where custom web development work actually pays off, because you can control the render path instead of fighting a plugin.
Layer 4: Content and AI Overview visibility
This is the layer that changed the most. In 2026 a meaningful chunk of informational queries get answered in an AI Overview or a similar surface, and the old “rank in position 1-3” framing doesn’t tell you whether you got cited.
You can’t reliably scrape AI Overviews at scale (it’s personalized, it varies by query, and the markup shifts). What you can do:
- Track branded search volume in Search Console. If AI answers are eating your traffic, branded queries usually hold up better than generic ones.
- Watch impressions vs. clicks on informational pages. Rising impressions with falling CTR on question-style queries is the fingerprint of an AI answer sitting above you.
- Write for citation, not just ranking. Clear definitions, specific numbers, named sources, and short direct answers to the question in the heading. That’s what gets pulled.
I’m not going to pretend there’s a clean tool for this yet. There isn’t. Anyone selling you an “AI Overview tracker” with a confident dashboard is selling you a scrape that breaks every few weeks.
Layer 5: Technical hygiene checks
The unglamorous stuff that still breaks sites:
- Structured data. Validate with the Schema Markup Validator, not just the Rich Results Test. The Rich Results Test only shows you types Google currently renders, so it’ll stay silent on valid markup that isn’t eligible for a rich result.
- Mobile rendering. Check on a real device, not just a resized browser window.
- HTTPS and mixed content. Still catches people after a CDN migration.
- Hreflang. Only if you actually have regional variants. Broken hreflang is worse than none.
- Sitemap accuracy. A sitemap full of noindexed or redirected URLs is a signal you don’t know your own site.
What I stopped using
A few things dropped out of my stack:
- Domain authority scores. They’re a third-party approximation of a metric Google doesn’t publish. Useful for a rough comparison, useless as a target. I don’t put them in reports anymore.
- Keyword density tools. Never useful. Write for the reader.
- Automated “SEO score” browser extensions. They flag things that don’t matter and miss things that do.
The order I actually run it
- Crawl the site, check index coverage in Search Console.
- Pull logs, find crawl waste and errors.
- Check field Core Web Vitals, especially INP.
- Review content against search intent, flag pages losing CTR to AI answers.
- Fix the technical issues, then wait. Nothing here is instant.
If you’re doing this for a local business, the local layer sits on top of all of it: Google Business Profile accuracy, NAP consistency, and location pages that aren’t thin duplicates of each other. That’s a different checklist, and it’s most of what Long Island SEO work actually comes down to for a lot of the businesses I talk to. The technical stack above still has to be sound first, or the local stuff can’t carry it.
FAQ
Do I need paid tools to run a real SEO audit?
No. Search Console, Screaming Frog’s free tier, PageSpeed Insights, and a log analysis script cover 80% of what matters. Paid tools save time and add competitive data, but they don’t find problems the free stack misses.
How often should I run a full audit?
Full audit twice a year for a normal site. Crawl and log checks monthly. If you ship code weekly, run the crawl after every deploy that touches routing or templates.
Is INP really more important than page load speed now?
They measure different things and both count. LCP is about how fast the main content shows up. INP is about how responsive the page feels once it’s loaded. In 2026, INP is the one that fails more often on sites with heavy JavaScript, so it’s where I look first.


