Last week I needed to audit a client site — check broken links, verify schema, sanity-check a sitemap, spot-check indexing on 40 URLs. Nothing exotic. I opened Google, typed the obvious queries, and clicked whatever ranked.
Four hours later I had my report, but I also had a very long list of ways free SEO tools are quietly broken. Not "missing features" broken — actively misleading broken. This post is that list, because I ended up building ToolsVale around the fixes and I think the pattern is worth writing down whether you build tools or just use them.
The setup
Twelve tools total, spread across the four jobs above: broken link checkers, schema validators, sitemap generators, indexing checkers. For each one I gave the same input a real site would give: 500 URLs for the link checker, a live JSON-LD block for the schema tool, an existing sitemap for the generator, 40 URLs for the indexing check.
I noted every single thing that broke, gated, or gave me an answer I couldn't trust. I'm not naming names — this is about pattern, not takedown — but if you've used a free SEO tool recently you've hit at least four of these.
The 8 patterns
1. The sign-up wall at result 5
Every free broken link checker I tried let me check 3–10 URLs before demanding an account "to continue." Not for advanced features. To see result #6.
The tools that do this are betting you're too invested to bounce. Sometimes they're right. Mostly you close the tab and try the next result.
The fix: no auth. If the crawl runs in the browser (fetch + concurrent workers), there's no server cost to gate. Even server-side, a 500-URL crawl is measured in cents, not dollars.
2. Redirect chains flattened to final destination
Nine of the twelve link checkers showed only the final URL in a redirect chain. So a URL that goes /page → /page/ → /new-page/ → 404 shows up as "404" with no indication of the two hops in between.
This matters because the redirect chain itself is the SEO problem. Each hop leaks link equity. A tool that hides the chain is hiding the actual work you need to do.
The fix: show every hop, every status code, every URL, in order. Half a day of dev work.
3. "Broken link" without the source page
Most broken link tools tell you the URL is broken. Almost none tell you which page on your site is still linking to it. So you have a 404, but you don't know what to edit to remove the link.
If you don't have the source, you can't fix the cause — only the symptom (by 301-redirecting the broken URL somewhere, which just adds a redirect chain, see problem #2).
The fix: during the crawl, store the referrer for every URL discovered. Trivially cheap. Nobody does it.
4. Schema validators that accept garbage
I fed a JSON-LD block to five free schema validators. Three of them said "valid" for a block that was missing required properties (@context, @type, and — in one case — a mandatory datePublished for Article schema).
They're technically running through a JSON linter, not a schema.org validator. But they're called "schema validators" and users assume the check means something.
Google's own Rich Results Test catches these. Free third-party tools mostly don't.
5. Sitemap generators that ignore rules
The sitemap.xml spec has real constraints: 50MB max file size, 50,000 URLs max per file, index files needed above that. Three of the four sitemap generators I tried produced a single flat file for a 65,000-URL input, in violation of the spec, and Google will reject it on ingestion.
The fix: split into sitemap-1.xml, sitemap-2.xml, etc., with an index. It's a while-loop.
6. Cached results shown as live
Two of the three indexing checkers I tested returned results in <100ms for a URL that had been published five minutes earlier. That's not a live check — that's a cached snapshot from days or weeks ago.
The tools don't say this. They just show a green "indexed" checkmark for a URL that Google has never seen.
The fix: either do a real live check (site: query, respecting rate limits), or clearly label the data source and age. Users can handle "cached from 3 days ago." They can't handle "green tick, in reality Google 404's your URL."
7. Robots.txt as an afterthought
Half the free crawlers I tested happily crawled /wp-admin/, /checkout/, /cart/, and anything else robots.txt would have disallowed a well-behaved crawler from touching. Some of these paths return sensitive data if you're logged in — which the tool won't be, but the point is a tool that doesn't respect robots.txt isn't a serious tool.
The fix: fetch and parse robots.txt before crawl, honor Disallow for User-agent: * at minimum. Small library away.
8. Hreflang tools without x-default
Free hreflang generators universally forget the x-default value. x-default is what Google uses when the visitor's language doesn't match any of the declared alternates. Skip it and you're telling Google "if the user speaks Portuguese and my site is only in English/Spanish/French, I have no opinion" — which becomes a soft-signal ranking issue.
Every generator I tried was missing this. Fix: add one more form field with a plain-English label ("Which language should show when nothing else matches?"). Ten minutes of work.
Why is it like this?
I don't think most of these SEO tools ship broken defaults out of malice. I think they ship as MVPs — a wrapper around a Python script or the Google Custom Search API, monetized with ads, then forgotten. The gaps aren't bugs to fix, they're features that would eat the paid tier or expose that the "free" checker is actually a lead magnet.
Which means the space is enormous, the incumbents are entrenched by SEO not quality (yes, SEO tools ranking on SEO — the irony writes itself), and it's genuinely open to anyone who ships a version that doesn't have these problems.
What I built
I ended up building ToolsVale — free browser-based tools for images, PDFs, data and SEO, currently 38 of them. The rule is: before any tool goes live, we run the same input through the popular alternatives and note where the output breaks. Those notes become the spec. Every claim on a tool page comes with a test you can run in under a minute.
A few examples for anyone curious:
- bulk URL status code checker — 500 URLs, full redirect chains shown, soft-404 detection, response times, and headers. Fixes problems #1 and #2 above.
- broken link checker — bulk broken link scanner that stores the source page for every broken URL, not just the destination. Fixes problem #3.
- trailing slash checker — finds URLs redirecting only because of a missing or extra slash, and traces back to the source page still linking to the wrong version. This is problem #3 applied to a very specific SEO gotcha.
- schema markup generator — outputs schema that actually passes Google's Rich Results Test, not just JSON lint.
-
hreflang generator — includes
x-defaultby default because that's the correct answer.
Most tools run entirely in the browser. The ones that need a server (like bulk URL checking, which can't be done purely client-side due to CORS) say so on the tool card with a stated deletion window.
The takeaway if you're not building tools
If you're just picking an SEO tool for a task, three things to check before you rely on any result:
- Give it a URL you know has a redirect chain (any
http://URL that ends up onhttps://with a trailing slash works). Does it show all hops, or only the final destination? - Give the schema validator a JSON-LD block with a deliberately missing required field. Does it catch it, or does it happily pass?
- Check whether the indexing checker returns instantly (<200ms). If yes, it's cached data, not a live check.
If you're building one, the good news is the bar is astonishingly low. Almost every "premium" feature these sites gate is a while-loop, a spec-compliance check, or storing one extra field during crawl.
The gap isn't technical. It's positioning. Anyone who ships the honest version wins.
Full tool set at toolsvale.com — free, no accounts, no watermarks, most run in your browser. Open source components at github.com/toolsvalewebsite.
If you build in this space and want to compare notes on the browser-only approach, I'm on X @toolsvale_web.
Top comments (0)