Soft 404 SEO: How to Find and Fix Soft 404 Errors

An important product or service URL appears in Google Search Console as a soft 404. The page loads in your browser, returns a successful response, and may even show a custom “not found” message. Should you redirect it, rewrite it, or change the server response?
The right fix depends on whether the URL represents a real, useful page. A soft 404 is not simply a missing page. It is a mismatch between what the HTTP response says and what the page appears to contain.
This guide explains how to find soft 404s in Google Search Console, verify the live response, decide whether to return content, redirect, or return a real 404, and avoid common problems in JavaScript and Next.js applications.
Ready to Grow Your Business with SEO?
Let's work together to improve your rankings, drive more traffic, and grow your business online.
What Is a Soft 404 in SEO?
A soft 404 is a URL that appears to Google to contain a missing, empty, or otherwise unavailable page, even though its response does not clearly communicate that status. A common case is a “Page not found” template that returns HTTP 200 OK. Google can also identify a page as a soft 404 based on its content or behavior; the status code alone does not determine Google's classification.
For example, /products/retired-model may return HTTP 200 and display only “Sorry, product not found.” The server says the request succeeded, but the page says the resource does not exist. Search engines and other systems receive conflicting signals.
The opposite mismatch also occurs. A legitimate service page may return HTTP 200 but contain almost no content because a JavaScript request failed. That page can look like a blank or incomplete result to a crawler, even though it appears complete to a visitor whose browser successfully loads the data.
Google may report a soft 404 in the Page Indexing report. This does not automatically mean the page is valuable or that every example URL needs a redirect. First determine what the URL is supposed to do.
Soft 404 vs. HTTP 404: What Is the Difference?
An HTTP 404 is a server response that says the requested resource was not found. An HTTP 410 indicates that it is gone. These are valid responses for URLs whose content has been permanently removed without a relevant replacement. Returning a real 404 is not inherently an SEO mistake.
A soft 404 describes how Google interprets the page, rather than one specific HTTP status code. The usual mismatch is a missing-page experience served with HTTP 200. Redirecting a missing URL to an unrelated page can also be interpreted as a soft 404 because the destination does not satisfy the original request.
| Situation | HTTP response | Appropriate treatment |
|---|---|---|
| A real, useful page exists | 200 | Keep the page available and provide its intended content |
| A resource was removed and has no relevant replacement | 404 or 410 | Show a helpful missing-page message and return the correct status |
| A resource moved to a close, relevant replacement | 301 or 308 | Redirect directly to the replacement |
| An item is temporarily unavailable | Usually 200 | Keep useful product information, explain availability, and offer alternatives |
| A missing URL displays an error template | 200 | Correct the response to 404 or 410 |
| A removed URL redirects to the homepage or an unrelated category | 3xx | Remove the irrelevant redirect; return 404/410 or redirect to a genuinely equivalent destination |
Don't try to make every URL indexable. The goal is to make the status, content, and intended outcome agree.
Why Google Reports a Soft 404
Common causes include:
- A not-found template returns 200. The page says the URL does not exist, but the application responds as if it were a successful page.
- A redirect sends visitors somewhere unrelated. Redirecting every deleted URL to the homepage, a generic category, or a broad search page does not provide a meaningful replacement.
- The page is empty or nearly empty. A valid route may render a title and shell but no main content, products, or useful explanation.
- JavaScript content fails to load. The browser may show data after client-side rendering, while Google's rendering process receives an empty state, loading indicator, or error.
- A template creates placeholder pages. Invalid slugs, expired listings, or missing database records can produce a generic page with a 200 response.
- A search or filter URL has no meaningful results. A large number of empty combinations can create low-value URLs that resemble missing pages.
- A migration leaves stale routes behind. Old URLs may return a generic app shell or get redirected to destinations that do not match the previous content.
- The page is blocked from required resources. If key scripts or API calls cannot be fetched, the rendered page may not show the content that makes the URL valid.
- The server sends inconsistent responses. CDN rules, middleware, bot protection, locale handling, or user-agent variation may make Google receive a different page from a normal visitor.
The diagnosis should be evidence-based. A URL may be classified as a soft 404 even when the response is 200, but changing every 200 response to 404 is not a suitable fix.
How to Find Soft 404 Errors in Google Search Console
Use the Page Indexing report to discover patterns, then inspect representative URLs. The report is not a complete list of every URL on your site, and its indexed data may lag behind a recent deployment.
1. Open the Page Indexing report
In the correct Search Console property, go to Indexing → Pages and review the “Why pages aren’t indexed” reasons. Open the soft 404 issue if it appears. Check the trend and examples, and note the first-seen or last-crawl information when available.
If you are not sure how the report relates to other indexing reasons, see the Google Search Console Page Indexing report guide.
2. Group example URLs by template and purpose
Do not treat every example as a separate defect. Group URLs by route pattern, CMS content type, template, and intended status. A group of hundreds of product URLs with one missing-data template points to a different root cause than several genuinely retired products.
Classify each group as:
- Should exist and be indexable: a real service, article, product, or category page.
- Should exist for users but not search: a utility or temporary page that still has a legitimate purpose.
- Should not exist: an invalid identifier or permanently removed resource.
- Should redirect: a moved resource with a close, relevant replacement.
3. Inspect the URL in Search Console
Use URL Inspection on a representative URL. Separate the indexed information from the live test:
- The indexed view reports what Google last processed; it may reflect an older version.
- The live test checks whether the current page can be fetched and rendered for the tests that tool supports. It does not guarantee indexing or predict every canonicalization decision.
Review the last crawl date, fetch result, crawl and indexing permissions, rendered output, and any reported issue. If the live page has already been corrected, do not keep changing it just because the older indexed record has not updated.
4. Check the actual HTTP status
Test the final response, following redirects. Use a GET request rather than relying only on a HEAD request; some applications and CDNs handle them differently.
curl -sS -L -o /dev/null -w "%{http_code} %{url_effective}\n" https://example.com/products/retired-model
In PowerShell, call curl.exe explicitly to avoid the curl alias:
curl.exe -sS -L -o NUL -w "%{http_code} %{url_effective}`n" https://example.com/products/retired-model
Record every redirect hop if the final response is unexpected. Also inspect response headers and the returned HTML. A final 200 response is only correct if the resource genuinely exists and provides a useful page.
5. Compare the source HTML with the rendered page
Check what the server returns before JavaScript runs, then compare it with the browser-rendered DOM. Look for:
- A real title and primary content in the initial response where expected.
- A loading state that never becomes useful content.
- “Not found” or “no results” text on a 200 page.
- Failed JavaScript bundles, blocked scripts, API errors, or empty JSON responses.
- A canonical pointing to a different or nonexistent page.
- A noindex directive or response header that conflicts with the intended state.
Use Search Console’s rendered-page information where available, and test with a crawler or browser that can capture both response code and rendered output.
6. Check server, CDN, and application logs
For a soft 404 that appears only intermittently, compare request timestamps and user agents in server or CDN logs. Check whether Googlebot receives a 403, challenge page, rate limit, unexpected locale, or a different response body. Verify Googlebot identity using Google's documented methods before treating a user-agent string alone as proof.
7. Check internal links and sitemap inclusion
Important, valid pages should be linked from relevant pages and included in the sitemap if they are canonical and intended for indexing. Remove deleted or redirected URLs from the sitemap. Update internal links that point to missing URLs instead of relying on redirects indefinitely.
For broader diagnosis, combine the report with a technical SEO audit checklist and your site's route inventory.
How to Fix a Soft 404
Choose the fix based on the URL's real purpose, not just the Search Console label.
If the page should exist
Restore the missing content or fix the template, data lookup, API, or rendering issue. Ensure the page returns 200 only after it has a meaningful page state. Include a useful title, primary content, and relevant navigation. If a valid record is temporarily unavailable, explain that state instead of showing a generic “not found” page.
If the page was permanently removed
Return HTTP 404 or 410 with a clear, helpful message. Do not return 200 for a missing resource. Keep useful navigation to related sections, but avoid disguising the error as a successful page.
If the content moved
Use a permanent redirect only when a close, relevant replacement exists. Redirect directly to the final destination rather than chaining through several URLs. If there is no suitable replacement, keep the old URL at 404 or 410. A redirect to a broad or unrelated destination can remain a soft 404.
If the page is a duplicate or alternate URL
Determine whether the URL should be consolidated with a genuinely equivalent canonical page. Use consistent canonical signals and internal links. Do not use a redirect or canonical to point unrelated pages together simply to remove a soft 404 warning.
If the page is an empty search or filter result
Avoid creating indexable pages for every empty combination. For a finite, valid category that temporarily has no inventory, decide whether the page still serves a useful purpose and give users meaningful options. For invalid or impossible combinations that should not exist, return an appropriate not-found response. Review faceted navigation SEO before changing filter behavior at scale.
JavaScript and Next.js Soft 404s
JavaScript applications can create a soft 404 in two different ways: the server returns 200 for a URL with no underlying record, or the initial response contains only an app shell and client-side code fails to render the real page.
Return a real 404 when a record does not exist
In the Next.js App Router, notFound() renders the nearest not-found UI and adds a noindex robots directive. Check for a genuine not-found result rather than treating every upstream failure as a missing record:
import { notFound } from 'next/navigation'
async function getProduct(id: string) {
const response = await fetch(`https://api.example.com/products/${id}`)
if (response.status === 404) {
return null
}
if (!response.ok) {
throw new Error(`Product request failed: ${response.status}`)
}
return response.json()
}
export default async function ProductPage({
params,
}: {
params: Promise<{ id: string }>
}) {
const { id } = await params
const product = await getProduct(id)
if (!product) {
notFound()
}
return <main><h1>{product.name}</h1><p>{product.description}</p></main>
}
Do not catch and suppress the notFound() control-flow exception. Also do not convert timeouts, 500 responses, or temporary API failures into 404s; surface or handle those as operational errors.
Check streaming behavior
Next.js can return HTTP 200 for a not-found UI if the response has already started streaming. The not-found page includes noindex, but if the requirement is a genuine HTTP 404 status, the existence check must occur before streaming begins. Review the current Next.js notFound() documentation for the behavior of your version and rendering configuration, especially when using Suspense or Cache Components.
Render useful content reliably
For pages that should exist, render essential content on the server or ensure that client-side requests reliably complete. An empty shell, permanent spinner, or generic fallback with HTTP 200 can look like a soft 404. Check the original response, JavaScript console, network requests, API status, and Google’s rendered version. The JavaScript SEO Guide and Next.js SEO Checklist cover related rendering checks.
Special Cases: Products, Filters, and Migrations
Ecommerce products
A temporarily out-of-stock product usually should remain a useful product page if it is expected to return. Show availability accurately and provide alternatives. If a product is permanently discontinued, redirect only to a truly equivalent replacement; otherwise, return 404/410 or keep a useful discontinued page when it continues to serve users. Avoid a 200 page that says only “product unavailable.”
Empty filtered pages
An empty result for a rare filter combination should not automatically become a broad redirect. Review whether the combination is a valid user destination, whether it can have products later, and whether it is intended to be indexable. Prevent unbounded combinations from generating thousands of thin or empty crawlable URLs.
Site migrations
After a migration, test high-value URLs and representative route patterns. Make sure old paths either redirect to relevant new pages or return the correct missing status. A generic app fallback that serves 200 for every unknown path, or a rule that redirects every old URL to the homepage, can create soft 404s. See the Website Migration SEO Checklist and Redirect Chains and Broken Links for related checks.
How to Validate a Soft 404 Fix
After deployment:
- Request the exact URL and confirm the final status and redirect destination.
- Inspect the response body and headers, including canonical and robots directives.
- Test the page with JavaScript enabled and confirm the primary content appears.
- Test more than one URL if the issue came from a shared template.
- Update internal links and sitemap entries to reflect the final canonical URL.
- Run URL Inspection’s live test where appropriate.
- Use Validate Fix in Search Console for the issue group when available.
- Monitor the validation state and later indexed data; allow time for Google to recrawl.
Validation is not a request to index every URL, and a successful live test does not guarantee that Google will index a page. Measure the technical fix separately from any later indexing or ranking change. For more on Search Console reports and validation, read the Page Indexing report guide.
Soft 404 Audit Checklist
| Check | Expected outcome |
|---|---|
| Page purpose | The intended status for each URL is documented |
| Missing resources | Return 404/410 rather than a 200 error template |
| Moved resources | Redirect only to a close, relevant replacement |
| Valid pages | Return 200 and include useful primary content |
| JavaScript | No failed request leaves an empty or misleading page |
| Next.js | Missing records trigger not-found handling; errors are not disguised as 404s |
| Filters | Empty or invalid combinations have a deliberate crawl and index policy |
| Sitemap | Contains canonical, indexable URLs that should exist |
| Internal links | Point to live destinations rather than missing URLs |
| Validation | Test the deployed response and representative template URLs |
Frequently Asked Questions
Is a 404 bad for SEO?
No. A 404 is appropriate when a page has been removed and no relevant replacement exists. It becomes a problem when important content returns 404 unexpectedly or when internal links and sitemaps continue pointing to missing URLs.
Does HTTP 200 cause a soft 404?
Not by itself. A 200 is appropriate for a real page. Google may classify a 200 page as a soft 404 when its content or behavior suggests the resource is missing, empty, or unavailable.
Should I redirect every soft 404?
No. Redirect only when a close replacement exists. Otherwise, restore useful content or return 404/410 for a genuinely removed resource. Redirecting unrelated URLs to the homepage can still be treated as a soft 404.
How long does it take Google to update a soft 404?
There is no guaranteed timeline. After the fix is live and accessible, Google must recrawl and reprocess the URL. Search Console may continue to show older indexed information in the meantime.
Can JavaScript cause a soft 404?
Yes. A route may return 200 but fail to load the content that makes it useful, or render an error state only after client-side execution. Compare the original HTML with the rendered page and inspect failed scripts and API requests.
How do I fix a soft 404 in Next.js?
For a genuinely missing resource, use notFound() and check that your rendering path returns the intended HTTP status for your Next.js version. For a valid page, fix the data or rendering failure and return useful content. Do not hide server errors by treating them as missing records.
Final Thoughts
Soft 404s are resolved by aligning the URL’s purpose, its actual content, and the HTTP response. A missing resource should not pretend to be a successful page, and a useful page should not appear empty because its data or scripts failed.
Use Search Console to find patterns, test real responses, and choose a fix that matches the URL’s intent. Then validate the deployed behavior across representative URLs instead of chasing a 100% index count.
Need Help Diagnosing Soft 404s?
I’m Sachin Pokharel, an SEO professional in Nepal. If Search Console reports soft 404s across important templates, a technical SEO audit can help identify whether the cause is routing, response handling, redirects, JavaScript rendering, or page quality.
Explore my SEO services in Nepal or request a Technical SEO Audit to discuss your website’s indexing issues.
Authoritative References
Frequently Asked Questions
Is a 404 bad for SEO?
No. A 404 is appropriate when a page has been removed and no relevant replacement exists. It becomes a problem when important content returns 404 unexpectedly or when internal links and sitemaps continue pointing to missing URLs.
Does HTTP 200 cause a soft 404?
Not by itself. A 200 is appropriate for a real page. Google may classify a 200 page as a soft 404 when its content or behavior suggests the resource is missing, empty, or unavailable.
Should I redirect every soft 404?
No. Redirect only when a close replacement exists. Otherwise, restore useful content or return 404/410 for a genuinely removed resource. Redirecting unrelated URLs to the homepage can still be treated as a soft 404.
How long does it take Google to update a soft 404?
There is no guaranteed timeline. After the fix is live and accessible, Google must recrawl and reprocess the URL. Search Console may continue to show older indexed information in the meantime.
Can JavaScript cause a soft 404?
Yes. A route may return 200 but fail to load the content that makes it useful, or render an error state only after client-side execution. Compare the original HTML with the rendered page and inspect failed scripts and API requests.
How do I fix a soft 404 in Next.js?
For a genuinely missing resource, use notFound() and check that your rendering path returns the intended HTTP status for your Next.js version. For a valid page, fix the data or rendering failure and return useful content. Do not hide server errors by treating them as missing records.