Soft 404 Errors: How to Find & Fix Them

Your page loads fine in a browser. The design looks normal, the URL works, and the server returns a 200 OK status code. But Google Search Console labels it "Soft 404" and refuses to index it. You check the page — it has content. So what's going on?

A soft 404 doesn't behave like a regular error. There's no broken page, no error message your visitors see, and no obvious server misconfiguration. Yet Google treats the page as if it doesn't exist — and that has real consequences for your site's visibility.

What Is a Soft 404 Error?

A soft 404 is a page that returns an HTTP 200 (success) status code but contains content that Google believes should be a 404 (not found) page. The server says "everything is fine," but the page itself tells a different story.

According to Google's official documentation, Google considers content for processing when a server returns a 2xx status code, but "if the content suggests an error for Google Search, an empty page or an error message, Search Console will show a soft 404 error."

The key distinction: a hard 404 is when your server correctly returns a 404 HTTP status code, telling browsers and crawlers that the page doesn't exist. A soft 404 is when the server says "200 OK" but the page content looks like a not-found page to Google.

Hard 404s are actually fine from an SEO perspective. Google expects them, handles them efficiently, and removes those URLs from its index over time. Soft 404s are the problem — they send conflicting signals that confuse Google's systems and waste crawl budget.

How Google Detects Soft 404s

Google doesn't just look at HTTP status codes. It analyzes the actual content of your page to determine whether it's a legitimate page or a disguised error. Here's what Google's systems check:

Content Analysis

Google's algorithms scan your page for patterns that suggest it's a not-found page. This includes:

Error-like phrases: Text like "Page not found," "This page doesn't exist," "No results found," "Sorry, nothing matched your search," or "The page you're looking for has been removed."
Empty or near-empty pages: Pages with minimal text content, placeholder text, or just a header and footer with nothing meaningful in between.
Error page templates: If your custom 404 page returns a 200 status code, Google will likely detect it as a soft 404 based on the content pattern.

Device-Specific Detection

Google evaluates pages separately for mobile and desktop. The same URL can be flagged as a soft 404 on mobile but not on desktop (or vice versa). This typically happens when responsive designs render different content amounts on different screen sizes, or when mobile rendering fails to load JavaScript-dependent content.

Rendering and JavaScript Evaluation

Google renders pages using a headless Chromium browser. If your page relies on JavaScript to load content and something goes wrong during rendering — a failed API call, a blocked script, a timeout — Google might see an empty page and flag it as a soft 404. This is a common issue with single-page applications (SPAs) and React/Vue/Angular sites.

Common Causes of Soft 404 Errors

Here are the most frequent causes, from the most common to the less obvious.

1. Custom 404 Pages Returning 200 Status Codes

This is the most straightforward cause. You've designed a beautiful custom error page that says "Oops, this page wasn't found!" with helpful links back to the homepage. But your server is returning a 200 status code instead of 404.

This happens frequently with:

Static site generators that create a generic fallback page for unknown routes
Single-page applications where the frontend router handles 404s but the server always returns 200
Misconfigured web servers where error page directives don't set the correct status code

How to verify: Open your browser's developer tools, go to the Network tab, and navigate to a URL you know doesn't exist on your site. Check the status code of the HTML response. If it says 200 instead of 404, you've found the problem.

2. Empty Search Results Pages

If your site has a search function, every unique search query generates a unique URL. When someone searches for "xyzabc123" and gets zero results, that page returns a 200 status code with essentially no useful content — just "No results found for 'xyzabc123'."

Google crawls these URLs (especially if they're linked from somewhere or appear in your sitemap) and flags them as soft 404s. This is extremely common on e-commerce sites where faceted navigation creates thousands of empty filter combinations.

Example: A clothing store has URLs like /shoes?color=purple&size=15&style=sandal. If no products match that combination, the page shows "0 items found" with a 200 status code. Google sees that as a soft 404.

3. Out-of-Stock or Discontinued Product Pages

E-commerce sites frequently run into this. A product page that used to have full details now shows "This product is no longer available" or "Out of stock" — but still returns a 200 status code. Google's algorithms can interpret this as a soft 404, especially if most of the original product content has been removed.

4. Thin Content Pages

Pages that technically exist but have almost no meaningful content get flagged. This includes:

Category pages with zero items
Tag pages with no associated posts
Author pages for authors who haven't published anything
Pagination pages beyond the actual content (page 47 of a blog that only has 12 pages of posts)

Google's threshold for "too thin" isn't publicly documented, but in practice, pages with only boilerplate navigation and footer — with no substantive unique content — are at risk.

5. JavaScript Rendering Failures

This is increasingly common and hard to diagnose. Your page looks fine in a browser because JavaScript loads and renders the content. But when Googlebot renders the page, one of the following happens:

A critical JavaScript file fails to load (maybe blocked by robots.txt or a CDN issue)
An API call times out or returns an error
The page requires authentication tokens that Googlebot doesn't have
Client-side rendering depends on user interaction to display content

The result: Googlebot sees a page with just the HTML shell — empty containers, loading spinners, or fallback "no content" messages. It flags the page as a soft 404.

A real-world case documented by SEO practitioners: a site had 48 JavaScript files loading on product listing pages. When even one failed to load, the product grid disappeared and showed "0 items found" — triggering a soft 404 for the entire page.

6. Irrelevant Redirects

When you redirect a deleted page to an unrelated page — like redirecting a discontinued product page to the homepage — Google can treat the redirect target as a soft 404 for the original URL. Google expects redirect targets to be relevant to the original content. A blanket redirect to the homepage for all deleted pages is a red flag.

7. Expired Content With Status Messages

Blog posts about past events ("Join us at our 2024 conference!"), expired promotions ("This offer ended on March 1"), or time-limited content that now displays a "This content is no longer available" message can trigger soft 404 detection.

How Soft 404s Hurt Your SEO

Soft 404s aren't just a cosmetic issue in Search Console. They have concrete SEO consequences.

Wasted Crawl Budget

Every time Googlebot visits a soft 404 page, it spends crawl budget on a URL that will never appear in search results. For small sites (under 1,000 pages), this is negligible. For large sites with tens of thousands of pages — especially e-commerce sites with extensive faceted navigation — soft 404s can consume a significant portion of your crawl budget.

Google's own crawl budget documentation confirms that soft 404 pages "will continue to be crawled, and waste your budget." Those crawl requests could be spent discovering and indexing your actual content instead.

Pages Excluded From the Index

Google won't index pages it identifies as soft 404s. If a legitimate page gets incorrectly flagged (a false positive), that page disappears from search results entirely. You might have great content that simply isn't showing up because Google thinks the page is an error.

Diluted Site Quality Signals

A high ratio of soft 404s to legitimate pages can signal to Google that your site has quality issues. If Google crawls 10,000 URLs on your site and 3,000 of them are soft 404s, that's a signal that the site has structural problems — lots of dead ends, thin pages, or poor content management.

Delayed Indexing of New Content

When Googlebot spends time recrawling known soft 404 URLs, it has less capacity to discover and index your new content. This creates a feedback loop: the more soft 404s accumulate, the longer it takes for your legitimate pages to get indexed.

How to Find Soft 404 Errors

Google Search Console

The primary tool for identifying soft 404s is the Page Indexing report in Google Search Console.

Open Google Search Console
Go to Indexing → Pages
Scroll down to the "Why pages aren't indexed" table
Look for the row labeled "Soft 404"
Click it to see all flagged URLs

The report shows you exactly which URLs Google considers soft 404s. For each URL, you can use the URL Inspection tool to see how Google rendered the page and why it was flagged.

Crawling Tools

Third-party crawlers can also help identify potential soft 404s before Google finds them:

Screaming Frog can detect pages returning 200 status codes that contain error-like phrases ("page not found," "no results")
Sitebulb specifically checks for "soft 404 phrases" in page content
Broken Link Checker (our Chrome extension) can report HTTP status results across discovered pages, but it does not classify page content as a soft 404. A 200 OK response remains a successful HTTP status in its report; use Search Console or a content-aware audit to determine whether Google treats that page as a soft 404.

Manual Testing

For individual URLs, use your browser's developer tools:

Open DevTools (F12)
Go to the Network tab
Navigate to the suspicious URL
Check the HTTP status code of the main document request
If it's 200 but the page content suggests "not found," you have a soft 404

How to Fix Soft 404 Errors: Step by Step

The fix depends on the cause. Work through your flagged URLs and categorize them before applying fixes.

Fix 1: Return Proper 404 or 410 Status Codes

When to use: The page genuinely doesn't exist or has been permanently removed.

If the content is truly gone, your server should return the correct HTTP status code:

404 (Not Found): The page doesn't exist. Google will eventually remove it from the index.
410 (Gone): The page was deliberately and permanently removed. Google removes these from the index faster than 404s.

For Apache (.htaccess): ErrorDocument points Apache at the page to serve, but the status code only stays 404 if you reference the file with a root-relative path (not an absolute URL) and the file is served statically. A common mistake is pointing ErrorDocument at an external URL, which makes Apache issue a 302 redirect instead:

# Correct — serves /404.html with a 404 status
ErrorDocument 404 /404.html

# Wrong — triggers a 302 redirect, then a 200 on /404.html
# ErrorDocument 404 https://yoursite.com/404.html

Verify the response with curl -I https://yoursite.com/does-not-exist — the first line should read HTTP/1.1 404 Not Found, not 200 OK or 302 Found. If your 404 page is a PHP or dynamic script, set the status code inside the script so it's returned regardless of how the file is reached:

<?php http_response_code(404); ?>

For Nginx: there's a subtle gotcha here. error_page 404 /404.html; preserves the 404 status, but error_page 404 = /404.html; (with the = sign) rewrites the response to 200. Always use the first form, and mark the error page internal so it can't be accessed directly:

error_page 404 /404.html;

location = /404.html {
    internal;
}

Test with curl -I https://yoursite.com/does-not-exist — the first line must read HTTP/1.1 404 Not Found, not 200 OK. If you see a 200, check whether your config is using the = form of error_page, or whether a try_files fallback is silently returning the file with a 200 status.

For Next.js / React apps: Make sure your server-side rendering or static generation returns the correct status code. In Next.js, use notFound: true in getServerSideProps or getStaticProps to return a 404 status code.

Fix 2: Add Meaningful Content to Thin Pages

When to use: The page should exist and be indexed, but Google flagged it because the content is too thin.

If Google is flagging a legitimate page as a soft 404, the page likely needs more content. Common scenarios:

Category pages with few items: Add descriptive text about the category, not just a product grid. Include a category description, FAQs, or buying guides.
Tag/archive pages: Add contextual introductions explaining what the tag covers and why the collected content matters.
Author pages: Add author bios, expertise descriptions, and links to their published content.

The goal is making the page clearly valuable and distinct from an error page. There's no magic word count, but a page with only navigation elements and a single line of text will be at risk.

Fix 3: Implement 301 Redirects to Relevant Pages

When to use: The content has moved to a new URL or has been consolidated with another page.

If a page was deleted but similar content exists elsewhere on your site, set up a 301 redirect to the most relevant replacement page. The key word is relevant — redirecting to the homepage or a generic category page when the original was a specific product or article can itself be treated as a soft 404.

Good redirect: /blog/old-seo-guide-2024 → /blog/updated-seo-guide-2026 Bad redirect: /products/discontinued-widget → / (homepage)

For more on handling redirects properly during site changes, see our guide on auditing links before a redesign.

Fix 4: Block Crawling of Legitimately Empty Pages

When to use: Pages that are functional for users but should never appear in search results.

Some pages are supposed to be empty or near-empty — internal search results, filtered views with no matches, paginated pages beyond actual content. These shouldn't be indexed, and you have several options:

Option A — Noindex meta tag:

<meta name="robots" content="noindex">

Option B — X-Robots-Tag HTTP header:

X-Robots-Tag: noindex

Option C — robots.txt (prevents crawling, not indexing):

Disallow: /search?
Disallow: /filter/

The noindex approach is generally preferred because it clearly tells Google "this page exists but shouldn't be in the index." Using robots.txt prevents Google from even seeing the noindex tag, so if the page was already indexed, it might stay indexed.

Fix 5: Fix JavaScript Rendering Issues

When to use: Pages that look fine in a browser but are flagged as soft 404s due to rendering failures.

Test with URL Inspection Tool: In Google Search Console, inspect the flagged URL and click "Test Live URL." Then view the rendered HTML and screenshot to see what Google actually sees.
Check robots.txt: Make sure you're not blocking JavaScript files, CSS files, or API endpoints that the page needs to render.
Implement server-side rendering (SSR): For JavaScript-heavy sites, SSR ensures Google gets fully rendered HTML without depending on client-side execution.
Add fallback content: If your page relies on an API that might fail, include meaningful fallback content in the initial HTML rather than showing "Loading..." or an empty state.
Monitor resource availability: Use Search Console's URL Inspection tool regularly to check that all page resources load correctly for Googlebot.

Fix 6: Handle Out-of-Stock Products Correctly

When to use: E-commerce sites with products that go in and out of stock.

Temporarily out of stock: Keep the page with full product information, pricing, and a "Notify me when available" option. The page has enough content to avoid being flagged as a soft 404.
Permanently discontinued: Either return a 404/410 status code or redirect to the closest alternative product. Don't redirect to the category page unless no alternative exists.
Seasonal products: Keep the page live with a note about seasonal availability. This preserves link equity and existing rankings.

Fix 7: Request Re-Indexing After Fixing

After applying fixes, tell Google to re-evaluate:

Go to Google Search Console
Enter the fixed URL in the URL Inspection tool
Click "Request Indexing"
For bulk fixes, use the "Validate Fix" button in the Page Indexing report's Soft 404 section

Google will re-crawl the fixed URLs and update their status. This typically takes a few days to a couple of weeks.

Dealing With False Positives

Sometimes Google flags pages as soft 404s when they shouldn't be. This happens more often than you'd think, especially with:

JavaScript-rendered pages where Googlebot had a temporary rendering failure
Pages with "not found" language in legitimate content
Pages that were temporarily down when Googlebot crawled them
Legitimate pages with unusual layouts that have minimal visible text but substantial non-text content (images, videos, interactive elements)

If you believe a page has been incorrectly flagged:

Verify the page renders correctly for Google: Use the URL Inspection tool's "Test Live URL" feature and review the rendered screenshot.
Check for transient issues: If the API your page depends on was down when Google crawled it, the flag might be based on that single bad crawl.
Add more textual content: Even if the page is visually rich, Google's soft 404 detection weighs text content heavily. Adding descriptive text can prevent false positives.
Request re-indexing: After confirming the page is rendering correctly, request re-indexing through the URL Inspection tool.

Be patient with false positives. Google may take several re-crawls to update its classification, especially if the page was flagged for an extended period.

Preventing Soft 404 Errors

Most of the fixes above can run as prevention if you build them into your workflow before soft 404s appear. Two habits matter most.

Audit Before Major Changes

Before a site migration, URL restructure, or major content cleanup, audit every URL that will change. Map old URLs to new ones and set up redirects to the correct equivalent pages — never a blanket redirect to the homepage, since Google treats that as a soft 404. Use a crawler like Screaming Frog to generate a complete URL list before making changes. Our guide on running a link audit before a website redesign walks through the process.

Monitor Search Console and Keep Your Sitemap Clean

Check the Page Indexing report at least monthly. Soft 404s accumulate gradually — a few new ones each week from out-of-stock products, deleted blog posts, or expired content. Only include URLs in your XML sitemap that return 200 and should be indexed; submitting soft 404 URLs actively invites Google to crawl them and flag the problem. Over time, link rot will break external links on its own, so ongoing monitoring is the only way to keep the count down.

FAQ

Are soft 404 errors the same as regular 404 errors?

No. A regular (hard) 404 error means the server correctly returns a 404 HTTP status code, telling browsers and search engines the page doesn't exist. A soft 404 means the server returns a 200 (success) code, but Google determines the page content looks like a not-found or empty page. Hard 404s are handled cleanly by search engines. Soft 404s cause confusion because the server and content send contradictory signals.

Do soft 404 errors hurt my search rankings?

Soft 404s don't directly penalize your rankings in the way a manual action would. However, they indirectly hurt SEO by wasting crawl budget, preventing legitimate pages from being indexed, and signaling site quality issues to Google. A site with thousands of soft 404s relative to its total page count is telling Google that a significant portion of its content isn't valuable.

How long does it take for Google to resolve a soft 404 after I fix it?

After fixing the issue and requesting re-indexing through Google Search Console, it typically takes a few days to two weeks for Google to re-crawl and update the page's status. For large batches of fixes, use the "Validate Fix" feature in the Page Indexing report — Google will systematically re-check all flagged URLs over the following weeks.

Can I ignore soft 404 errors if they're on pages I don't care about?

If the flagged pages are genuinely not important (empty search result pages, expired promotional pages, test URLs), you can address them by either returning a proper 404/410 status code or adding a noindex tag. Ignoring them entirely means Google will keep crawling them and wasting your crawl budget. The fix doesn't need to be complicated — a proper 404 status code or noindex tag is sufficient.

Why does Google flag my page as a soft 404 when it clearly has content?

False positives happen. Common causes include: JavaScript rendering failures during Googlebot's visit, temporary API downtime that caused the page to load without content, phrases in your content that match Google's error-detection patterns, or the page having too much boilerplate relative to unique content. Use the URL Inspection tool to see exactly what Google sees when it renders your page, and request re-indexing after confirming the page renders correctly.

Soft 404 Errors: What They Are and How to Fix Them