How to Check HTTP Status Codes? What Do 200, 301, 302, 404, and 500 Mean?

In daily website maintenance or SEO work, you often encounter frustrating issues. For example, you can open a page in your browser, but your SEO monitoring tool keeps alerting you about multiple redirects. Some old links were deleted long ago, yet search engines keep crawling them and reporting dead link errors. Sometimes your website suddenly goes down, displaying a glaring "server error" message.

When facing these problems, just looking at the page in a browser won't reveal the root cause. The fastest and most accurate way to troubleshoot is to check the HTTP status code returned by that URL. In this article, we'll skip the complex protocol theory and dive straight into practical troubleshooting, explaining how to check HTTP status codes and what the core codes 200, 301, 302, 404, and 500 mean.

1. What Is an HTTP Status Code?

When you visit a webpage in your browser, the browser sends an HTTP request to the server. After the server receives and processes the request, it returns the page content along with a three-digit HTTP status code.

For example, a normal page might return:

HTTP/1.1 200 OK

If the page has been permanently moved to another address, it might return:

HTTP/1.1 301 Moved Permanently

These numbers are not random; they indicate the status of the request processing.

They can be broadly categorized as follows:

For daily website maintenance or SEO, you don't need to memorize all status codes. The ones you'll actually encounter most are 200, 301, 302, 404, and 500, with 403, 502, 503, and 504 also being fairly common.

2. How to Check HTTP Status Codes?

To find out whether a webpage returns 200, 301, 302, 404, or 500, the most direct method is to check the actual HTTP response of that URL. While browsers can show status codes, they automatically follow redirects like 301 and 302 during normal browsing, so you often only see the final page and miss the intermediate statuses. For webmasters and SEO professionals, using a dedicated HTTP status code checker is more straightforward.

2.1 Use the Chahu HTTP Status Code Checker

Open the HTTP Status Code Checker page on Chahu.

Once on the page, enter the full URL you want to check, for example:

https://www.example.com/page

Click "Start Check" to see the current HTTP status returned by that URL.

For example:

https://www.example.com/              → 200 OK

https://www.example.com/old-page      → 301 Moved Permanently

https://www.example.com/test          → 404 Not Found

Compared to simply checking whether a page opens, this method provides more complete HTTP-level information.

In addition to the final status code, Chahu lets you view the redirect chain, final destination URL, response IP, response headers, and request time. If a page has multiple redirects, you can see what status each hop returns, which is useful when checking 301, 302, or HTTPS redirects.

For example, when a user visits:

http://example.com

The browser might eventually open:

https://www.example.com/

But the actual request process might be:

http://example.com
        ↓ 301
https://example.com
        ↓ 301
https://www.example.com/
        ↓ 200

If you only look at the final page, you might assume the URL always returns 200. By checking the HTTP status, you can see the entire redirect chain.

For SEO checks, also pay attention to the X-Robots-Tag in the response headers. Sometimes a page returns 200 and appears accessible, but the server sets noindex in the response header, preventing the page from being indexed. Therefore, when checking a URL, don't just look at whether it returns 200; also consider the final URL, redirect chain, and response headers.

2.2 Batch Check Multiple URLs

If you only need to check one page, the HTTP status code checker above is sufficient.

However, during website redesigns, dead link checks, or SEO page audits, you often encounter dozens or even hundreds of URLs. Entering them one by one is tedious. In such cases, you can use Chahu's batch check feature:

For example, if you've just changed your URL structure, you can batch check old page URLs to quickly identify:

200    Normal page
301    Permanent redirect
302    Temporary redirect
404    Page not found
5xx    Server error

First categorize URLs by status code, then handle each group. This is much more efficient than checking pages one by one.

2.3 Use Browser Developer Tools

If you just need to check a single page temporarily, you can also use the developer tools in browsers like Chrome or Edge.

The steps are simple:

Open the webpage
   ↓
Press F12
   ↓
Go to the Network tab
   ↓
Refresh the page
   ↓
Find the corresponding request
   ↓
Check the Status

For a normal page, you'll typically see:

Status Code: 200 OK

For a permanent redirect, you might see:

Status Code: 301 Moved Permanently

The advantage of browser developer tools is that you can view detailed request and response information. However, if you just want to quickly determine a URL's status or check the full redirect chain, using a dedicated HTTP status code checker is more intuitive.

3. What Do HTTP 200, 301, 302, 404, and 500 Mean?

3.1 What Does HTTP 200 Mean?

200 OK is one of the most common HTTP status codes. It indicates that the server successfully received and processed the request and returned the corresponding content.

For example:

https://example.com/product
        ↓
200 OK

For a webpage that exists and is meant to serve content, returning 200 is generally the expected result.

Examples include:

• Homepage

• Product detail pages

• Normal article pages

• Category pages

• API responses with normal data

These pages should typically return 200.

However, there's a subtle point that's easy to overlook: Returning 200 does not guarantee the page is completely healthy.

For instance, if a product has been deleted and the page displays "Sorry, this product does not exist," but the server still returns 200 OK, from the server's perspective the request succeeded, but the page has no meaningful content. Search engines may treat this as a Soft 404. So when auditing a site, HTTP status codes are just the first layer of checks; for important pages, you should also examine the page content. Google explicitly recommends that truly non-existent pages should return a proper 404 status rather than showing a "page not found" message while still returning 200.

3.2 What Does HTTP 301 Mean?

301 indicates a permanent redirect. It tells visitors and search engines that the URL has been permanently moved to a new address.

For example, when accessing example.com/old-page, the server returns 301 and automatically redirects to example.com/new-page.

Common use cases include:

• Redirecting HTTP to HTTPS

• Redirecting non-www to www (or vice versa)

• Changing to a new domain

• Restructuring the site and changing URL paths

• After removing an obsolete page, permanently redirecting it to a highly relevant replacement

If an old page's URL has permanently changed, you should generally use 301 rather than keeping 302 for a long time. This helps search engines understand the migration relationship between the old and new URLs and smoothly transfer the old page's authority and historical value to the new one.

3.3 What Does HTTP 302 Mean?

302 indicates a temporary redirect. It means the page is temporarily moved to a new address, but the original URL remains valid in the future.

For example, if your site is running a short-term promotional campaign:

/product → 302 → /summer-sale

After the campaign ends, you plan to restore the original page, so using 302 is appropriate.

When auditing a site, if you find that a page that should be permanently moved is returning 302 for an extended period, it's worth checking whether the redirect rules on your server or CDN are configured correctly. Incorrectly using 302 instead of 301 can cause search engines to delay updating their index, or even lead to the old and new pages competing with each other in search results.

3.4 What Does HTTP 404 Mean?

404 (Not Found) is one of the most common status codes for webmasters. It means the server can respond normally, but it cannot find the requested page.

For example, if a product page like example.com/product/123 has been removed and no replacement content is provided, users will receive a 404 Not Found when they visit it again.

Common causes:

• The page was manually deleted or taken down

• The user typed the URL incorrectly

• After a site redesign, old links are broken and no redirect was set up

• Navigation or internal links within articles point to incorrect URLs

• External sites link to a wrong URL

A few legitimate 404s are not a big deal; search engines have some tolerance for 404s. What really needs attention is when a large number of previously valuable pages suddenly return 404, or when internal navigation and article links continue to point to these dead URLs.

If there is an equivalent replacement page, consider setting up a 301 redirect. If the page is permanently deleted and there is no corresponding content, it's fine to leave it returning a proper 404. Avoid force-redirecting all 404 pages to the homepage with 301.

3.5 What Does HTTP 500 Mean?

500 (Internal Server Error) indicates a server-side error. The key difference between 404 and 500 is that 404 means the server is working but cannot find the page, while 500 means the server itself encountered an issue while processing the request and cannot execute code or fetch data properly.

For example, it returns: HTTP/1.1 500 Internal Server Error

Common causes:

• Backend code errors or syntax issues in PHP, Java, Node.js, etc.

• Database connection failures, timeouts, or outages

• Plugin or theme conflicts in systems like WordPress

• Incorrect file permissions on the server (e.g., misconfigured .htaccess)

• Web server (Nginx/Apache) running out of memory or hitting connection limits

Troubleshooting steps:

1. First, check the HTTP status code to confirm if it consistently returns 500.

2. After ruling out individual user network issues, check the server's operational status.

3. Review web server logs (e.g., Nginx error.log) and backend application logs.

4. Check the connectivity between the application and the database.

5. Investigate recent changes to code, configuration files, or plugin updates.

4. What's the Difference Between 200, 301, 302, 404, and 500?

If you just need a quick reference, look at the table below:

In practice, the ideal situation isn't that all URLs must return 200, but that the status code matches the page's current purpose. Normal pages should return 200, permanent moves should use 301, temporary redirects should use 302, deleted pages with no replacement can legitimately return 404, and 500 errors should be resolved as soon as possible.

5. When Should You Check HTTP Status Codes?

HTTP status codes aren't just for when your website is down. They're useful in many everyday scenarios:

5.1 After a Website Redesign

Especially if the URL structure has changed, batch check the important URLs from the old site to confirm:

Old URL → Does it return 301? → Does it redirect to the correct new URL?

Don't wait until Google's indexing changes to start troubleshooting.

5.2 After Migrating Servers

After a server migration, check core URLs like the homepage, articles, products, and APIs to see if any suddenly return 404, 500, 502, or time out.

5.3 When Upgrading from HTTP to HTTPS

In this case, focus on checking:

http://example.com
        ↓
Does it correctly return 301?
        ↓
https://example.com

Make sure you don't have both HTTP and HTTPS versions returning 200 simultaneously.

5.4 Checking for Dead Links

Batch check URLs from your crawl, old sitemaps, or historical page lists to quickly filter out:

404
410
5xx
Abnormal 301

Then handle each category accordingly.

5.5 When Launching a New Website

After a site goes live, run an HTTP check on important URLs like the homepage, navigation, product pages, registration/login, payment gateways, and APIs. This is more likely to uncover hidden issues than manually clicking through a few pages.

Summary

HTTP status codes might seem like just a few numbers returned by the server, but in website maintenance and SEO, they are often the fastest way to identify the direction of a problem. A page returning 200 at least indicates the server can complete the request. A sudden 301 or 302 suggests a redirect is happening. A 404 requires you to determine whether the page was truly deleted or if the site redesign left broken links. If you see a 500, the focus should shift to the server and backend application.

For checking a single page, you can use browser developer tools. For site launches, URL redesigns, SEO audits, or handling a large number of pages, batch tools like Chahu are much more convenient. First categorize URLs by status code, then investigate redirects, dead links, and server errors separately. This is usually far more efficient than manually checking pages one by one.

Related Q&A

1. After moving to a new server, many pages intermittently return 500, but they work after a refresh. What's going on?

This is usually not a hard-coded error in your code, but rather the connection pool or database connection limit being reached. The new server might have a low default max_connections setting. When traffic increases slightly, new requests can't get a database connection, causing PHP or Java applications to throw a 500. After a refresh, previous requests release connections, so new requests work again. You'll need to check the backend's slow query logs and connection count monitoring; simply looking at status codes won't reveal this.

2. If a page is deleted, is it better for SEO to return a 404 or set up a 301 redirect to the homepage?

It depends. If the old page had significant traffic and the homepage can genuinely satisfy the user's search intent, a 301 to the homepage is acceptable. However, if you're just being lazy and redirecting all non-existent links to the homepage, search engines may view this as a form of soft 404, which can harm your site's trust score. Google's official guidelines also mention that if a page is truly gone and there's no replacement, returning a proper 404 is cleaner than redirecting arbitrarily.

3. When checking for dead links, besides 404, what other status codes are often overlooked?

The 410 status code is often overlooked. It indicates that the resource has been permanently deleted and will not be restored, which is more explicit than 404. Also, 403 Forbidden is common; it means the resource exists but you don't have permission to access it. For search engines, this is different from not found. If you don't want crawlers to access a resource, configuring robots or returning 403 are both compliant methods. Another one is 429 Too Many Requests, which indicates that your crawl rate is too high and you're being rate-limited. In that case, you should adjust your crawler's speed, not fix links.

4. Why does a non-existent page sometimes return a 200 status code, but the page content says "Page not found"?

This is usually caused by the "graceful degradation" mechanism in CMS systems or frameworks. For example, in WordPress, if you don't have a dedicated 404 template, the system might automatically load index.php and output a "No content found" message, but the server response header still returns 200. In the tech community, this is called a "soft 404." The solution is to explicitly check at the server level (e.g., Nginx configuration) or in the application entry point, and if content is not found, force the response code to 404 using http_response_code(404).