# 404 vs 410 vs redirect: what to do with removed pages

> When a page goes, choose per URL between a 301 to its equivalent, a 410 for pages gone for good, or a plain 404. This guide gives the decision rules, the server snippets and the bulk workflow for a whole list of removed URLs.

Updated 2026-09-25 · Technical SEO · HTML version: https://getreport.app/guides/404-vs-410-vs-redirect-what-to-do-with-removed-pages

Every removed page needs an answer for the visitors and crawlers that keep arriving at its address: send them somewhere better, tell them it is gone for good, or say it was never here. Picking the wrong one costs traffic (a deleted page with backlinks), trust (a redirect to the home page) or years of wasted crawling (a 404 that Google keeps retrying). This guide gives the decision rule per page, the server snippets for each answer, and a workflow that handles a list of hundreds of removed URLs in one afternoon.

## Quick answer

| The removed page… | Answer with | Because |
| --- | --- | --- |
| has a live equivalent with the same intent (renamed, merged, replaced product) | **301** to that page | Visitors and ranking signals carry over |
| is gone for good with no equivalent | **410 Gone** | Google drops it faster than a 404 and stops retrying sooner |
| never existed, or you do not know (typos, scraped URLs) | **404** | The default; nothing to maintain |
| has backlinks or steady traffic but no exact equivalent | **301** to the closest match (category, parent, topic hub) | A link to your site is worth keeping |
| is temporarily unavailable (seasonal product, maintenance) | keep it **200**, say when it returns; or **302** for a short time | The URL will be back |

Never redirect a removed page to the home page (Google treats it as a soft 404), never use `noindex` to "remove" a page that no longer exists, and make sure the 404 page itself answers 404, not 200.

## Why the answer matters

A URL does not stop receiving visits when you delete the page. Search results, other sites, bookmarks and old emails keep sending people there for years. What they find decides whether you keep them, and what Googlebot finds decides how long the address keeps consuming crawl budget.

The three status codes say different things. **301** says "moved permanently, go here instead": the browser follows, and Google transfers the old URL's signals to the new one over the following weeks. **410** says "gone, do not come back": Google removes the URL from the index and stops checking as often. **404** says "not found" without saying why: Google removes it too, but keeps retrying for longer in case it was a mistake. In the long run Google [documents](https://developers.google.com/search/docs/crawling-indexing/http-network-errors) that it treats 404 and 410 the same; the difference is speed, and for a large clean-up speed matters.

The expensive mistakes are the ones that look like solutions. Redirecting everything to the home page produces one working link and a thousand confused visitors; Google classifies those redirects as soft 404s and ignores them. A 404 page that returns 200 ("Sorry, not found" with a success status) tells Google the page exists, so it stays in the index as a thin page and every broken link on the web looks alive. And `noindex` on a page that no longer serves anything is a contradiction: the page must be served (with a 200) for the tag to be read.

## How getReport checks it

> **Free tool:** [Bulk URL checker: status codes and redirects for up to 1,000 URLs](https://getreport.app/tools/bulk-url-checker): Paste up to 1,000 URLs and get the HTTP status, the final URL after redirects, the number of hops, the time to first byte, the content type and the noindex and canonical signals of every one, in one table you can filter and download as CSV. Free, no account, no cap at 500.

The bulk URL checker is where a list of removed URLs becomes a list of decisions. Paste up to 1,000 addresses; each is requested with a GET, following up to 10 redirects through the same guard as the reports, at most four at a time per host. The table shows the final status, the result label, the final URL, the hop count, the time to first byte, the content type and, for HTML, the title and canonical:

![The bulk URL checker results table with one row labelled Not found (404), one labelled Redirect chain with three hops, and the rest OK](https://getreport.app/guides/img/404-vs-410-vs-redirect-what-to-do-with-removed-pages/bulk.webp "Status codes per URL; the 404 and the three-hop chain stand out from the working rows.")

Three findings from the single-page report describe the same problems from the other side, on the pages that link to removed URLs and the sitemap that still lists them:

> **Check: Broken links.** A link to a 404 page is a dead end for visitors and a wasted crawl for search engines. Old campaign or product pages are the usual cause.
>
> 1. Update or remove each link listed in the technical detail; redirect the missing pages if they still get visits.
> 2. In WordPress, a plugin such as Broken Link Checker finds these site-wide.

The checker collects up to 100 same-host and 50 external links from the page, requests each with HEAD (and one GET when the server refuses HEAD), and counts 4xx, 5xx and no answer as broken. The list is per link, with the anchor text, so you can find the link in the editor. A 410 is counted as broken here too, which is correct: the link should go, even if the status was the right choice.

> **Check: The URL loads without a redirect chain.** Each redirect is a full round trip before the browser can start loading, often 100–300 ms on mobile. Search engines pass less value with every hop and stop following after a few.
>
> 1. Point every old URL straight at the final one (a single 301), and update internal links to use the final URL directly.
> 2. Look for rules that stack, for example http → https, then non-www → www, then trailing slash; combine them into one rule.

Removed pages that were "fixed" twice (a redirect to a page that was then removed and redirected again) show up as chains. The finding passes at one hop and warns from two; the hop list tells you where the chain goes.

> **Check: Sitemap URL status.** A sitemap should list only pages that answer 200. Redirects, 404s and noindex pages in it waste crawl budget and make Google trust the file less.
>
> 1. Remove deleted pages from the sitemap and list the final URL of redirected pages.
> 2. Most CMS plugins do this automatically; if you generate the file yourself, rebuild it from the live URL list before publishing.

The validator samples up to 25 listed URLs and expects each to answer 200 directly. A sitemap that lists 404s, 410s or redirects is the most common sign that pages were removed without a process, and it costs the file credibility with Google.

## Step by step

### 1. Get the list of removed URLs

Sources, in order of usefulness: the CMS trash and "unpublished" lists, the old sitemap (or the Wayback Machine's copy of it), Search Console's Pages report under "Not found (404)", the 404 log of your server or of the Redirection plugin, and the broken links found on your own pages. Put every URL in a spreadsheet, one per row.

### 2. Run the list and read the statuses

Paste the list into the bulk URL checker. Download the CSV; the columns you need are `url`, `status`, `final_url`, `hops`, `redirect_type`, `title` and `result`. Sort by `result`:

- **Not found** (4xx): currently 404 or 410; these are the rows to decide.
- **Redirect** / **Redirect chain**: already handled; check `final_url` is a sensible page and not the home page, and collapse any chain (`hops` ≥ 2).
- **OK**: not removed after all, or a soft 404 (a 200 with a "not found" title). The `title` column shows the second kind.
- **Server error**: the page crashes rather than being gone; fix or remove it properly.

### 3. Decide per row

Add a column `action` with one of `301`, `410`, `404`, and a column `target` for the 301 rows. Work through the rules from the quick answer, and use two extra columns to make the decision fast: `backlinks` (from your backlink tool: any external link means "keep the value", so 301) and `visits` (landing-page sessions in the last 12 months from analytics: steady visits mean the same).

The "closest match" for a 301 is the page a visitor who wanted the old one would settle for: the replacement product, the category the product lived in, the updated version of the article, the hub for the topic. If nothing on the site is close, the honest answer is 410.

> **Note:**
> Google's Removals tool in Search Console hides a URL from results for about six months; it does not remove anything. Use it for urgent cases (a leaked page) alongside a real 404, 410 or `noindex`, never instead of one.

### 4. Implement the 301s

**nginx**, in the `server` block, one `location` per URL (exact match with `=`):

```nginx
location = /products/red-shoes-2019/ { return 301 /shop/red-shoes/; }
location = /blog/launch-post-old/    { return 301 /blog/launch-post/; }
```

**Apache**, in `.htaccess` at the site root (`mod_alias`):

```apache
Redirect 301 /products/red-shoes-2019/ /shop/red-shoes/
Redirect 301 /blog/launch-post-old/    /blog/launch-post/
```

For a few hundred rows, generate the lines from the spreadsheet with a formula (`="Redirect 301 "&A2&" "&B2`) rather than typing them; a typo in a redirect target is a new broken link.

### 5. Implement the 410s

**nginx**:

```nginx
location = /events/2021-conference/ { return 410; }
location ^~ /catalogue-2019/        { return 410; }  # a whole removed section
```

**Apache**, either form:

```apache
Redirect gone /events/2021-conference/
RedirectMatch gone ^/catalogue-2019/.*$
```

or with `mod_rewrite`, where `[G]` is the "gone" flag:

```apache
RewriteEngine On
RewriteRule ^events/2021-conference/?$ - [G,L]
```

The visitor sees your error page in both cases; only the status code differs. Do not redirect 410 URLs to a "this page was removed" page, that would be a 301 to a page that says 410, which is a soft 404.

### 6. Let the 404s be 404s

URLs that never existed need no rule: the server answers 404 on its own. What they need is a 404 page that helps. It should:

- return the status code 404 (check it in the bulk checker: the result must read Not found, not OK);
- keep the site header, navigation and footer, so the visitor is still on your site;
- offer a search box and links to the top five sections;
- say plainly that the page does not exist, without blaming anyone;
- not be cached for long or indexed (search engines ignore 404 bodies anyway).

In WordPress, that page is the theme's `404.php`; WordPress already sends the 404 status for it. On nginx, `error_page 404 /404.html;` serves a static file with the right code; on Apache, `ErrorDocument 404 /404.html`.

### 7. Take removed pages out of the sitemap

A CMS-generated sitemap drops a page when it is unpublished or deleted. A sitemap built by a script or by hand keeps listing it until someone rebuilds the file. Either way, the sitemap must list only URLs that answer 200: 301 targets belong in it, the 301 sources and every 410 do not. Run the [sitemap validator](https://getreport.app/tools/sitemap-validator) afterwards; the sampled table should show 200s only.

### 8. Remove the links to them

Redirects and 410s answer the requests that still arrive; they do not stop your own site from sending them. Run the [broken link checker](https://getreport.app/tools/broken-link-checker) on the pages most likely to link to removed content (hubs, old posts, footers) and update or remove each link. For 301 rows, replace the link with the target; for 410 rows, remove the link and keep the text.

## Platform notes

### WordPress

Deleting a post or page makes WordPress answer 404 at its address, which is the right default. For the 301 and 410 rows, the Redirection plugin (free) handles both: a redirect rule with the target, or an "Error" action with the status code of your choice. Yoast SEO Premium's redirect manager offers "410 Content Deleted" as a redirect type and prompts you to create a redirect each time you delete a post, which is the cheapest way to make the decision at the moment it matters. Rank Math's redirect module does the same and includes a 410 option.

WooCommerce products go to the trash rather than disappearing; a trashed product answers 404 until it is deleted permanently. Products that are merely out of stock should stay live (see the `woo-oos-indexable` check in the WordPress Doctor); products that are gone for good are a 301 to the replacement or the category.

### Shopify

Deleting a product or page produces a 404 automatically. Add a redirect under Online Store → Navigation → URL Redirects for the rows that need a 301; Shopify has no 410, so pages gone for good stay 404, which is fine. Shopify's 404 page already returns the correct status.

### Static sites

Delete the source file and the page is a 404. Redirects go in the host's rules file (`_redirects` on Netlify, `vercel.json` on Vercel); both support a status code per rule, and Netlify accepts `410` as the status.

## Verify

- Re-run the bulk list. Every `301` row shows `hops` = 1 and a 200 at `final_url`; every `410` row shows status 410; every `404` row shows 404; no row shows Redirect chain.
- `curl -sI https://example.com/events/2021-conference/ | head -1` prints `HTTP/2 410`.
- Your 404 page, requested at a made-up address, returns 404: `curl -sI https://example.com/this-does-not-exist/ | head -1`.
- The sitemap validator's sampled URLs are all 200, and the broken link checker on your hub pages reads "All … checked links work".
- In Search Console, "Not found (404)" stops growing and the 410 URLs disappear from the index over the following weeks. Removed pages that had inbound links should appear in "Page with redirect" once, then drop out.

## Common mistakes

- **Everything to the home page.** The classic. Google reports it as a soft 404 and the redirect passes nothing; visitors land on a page that has nothing to do with what they clicked. Redirect to the closest match or answer 410.
- **A 404 page that returns 200.** Usually a JavaScript app or a misconfigured CMS. Google indexes the "not found" page under hundreds of URLs. Test with the bulk checker: the result must say Not found.
- **`noindex` on a deleted page.** The page has to be served for the tag to be read, so this is a 200 that pretends to be gone. Use 404, 410 or a 301.
- **Redirecting to a page that is later removed.** Two rounds of clean-up produce chains, and a chain that ends in a 404 is a broken redirect. Re-run the old list after every clean-up; [Redirect chains after a migration](https://getreport.app/guides/redirect-chains-after-a-migration-finding-every-hop) covers collapsing them.
- **Removing pages that still bring visitors.** Check `visits` and `backlinks` before choosing 410. A page with links from other sites is an asset to redirect, not a liability to delete.
- **Leaving removed URLs in the sitemap.** Google fetches them, finds 404s, and trusts the file less. The sitemap lists what exists, nothing else. For pages that are unreachable rather than removed, [Orphan pages](https://getreport.app/guides/orphan-pages-finding-and-linking-them) is the guide.