HTTP 3xx Status Codes (300–308): How 301, 302, 303, 307 and 308 Differ

orange and black signange

Contents

Got a question about your site?

Book a short consultation – I will tell you where to start.

3xx codes (Redirection) are a class of HTTP status codes that tell the client: ‘to get the resource, you need to take one more step’. Usually that step is fetching the URL from the Location header; in the case of a 304, it’s reaching for the cached copy. The HTTP specification (RFC 9110) defines nine codes, from 300 to 308. For SEO, four of them matter: 301 and 308 are permanent redirects – Google shows the new URL in the results – and 302 and 307 are temporary redirects – the old URL stays in the results. The difference within each pair is purely technical: 307 and 308 guarantee that the request method won’t change (a POST stays a POST), while with 301 and 302 the browser may switch POST to GET.

Below you’ll find a table of all the codes from 300 to 308, the differences between the 301/308 and 302/307 pairs, how 3xx codes interact with the request method and caching, an explanation of 303 and 304, and of the mysterious ‘307 Internal Redirect’ entry you see in Chrome. This is an overview of the codes as part of the HTTP protocol. If you’re looking for ready-made code for .htaccess, Nginx, PHP or WordPress, head over to my guide on how to set up a 301 redirect.

HTTP 3xx codes (300–308) – table

CodeNamePermanent / temporaryPreserves method?When to useSEO impact
300Multiple Choices––Practically never – the server offers several variants of the resource to choose from.No practical significance.
301Moved PermanentlyPermanentNot necessarily (POST may become GET)A permanent change of address: new slug, structure, domain, HTTPS, merging content.A strong signal that the new URL is canonical. The target URL appears in the results.
302FoundTemporaryNot necessarily (POST may become GET)A short-term change: maintenance, a short promotion, an A/B test.A weak signal – the source URL usually stays in the results.
303See OtherTemporaryNo – the next request is a GET (or HEAD)After a form submission (the POST → redirect → GET pattern).Google treats it as a temporary redirect. Not for moving content.
304Not ModifiedNot a redirectApplies to conditional GET/HEADA response to a conditional request when the resource hasn’t changed (cache).No effect on indexing; saves bandwidth and resources during crawling.
305Use Proxy––Don’t use – the code is deprecated.None.
306(Unused)––Don’t use – the number is reserved and the code unused.None.
307Temporary RedirectTemporaryYes – the method must stay the sameA temporary move where preserving the method matters (APIs, forms). Also shows up as ‘307 Internal Redirect’ with HSTS in the browser.Google treats it the same as a 302.
308Permanent RedirectPermanentYes – the method must stay the sameA permanent move that preserves the method (APIs, endpoints accepting POST).Google treats it the same as a 301.

How to read the table in practice: for ordinary pages (which the browser and Googlebot fetch with GET) the ‘preserves method’ column doesn’t matter, so the choice comes down to one question: ‘permanent or temporary?’. For permanent changes you use a 301 (or 308), for temporary ones a 302 (or 307).

How a 3xx code works and where four similar codes came from

The first digit of an HTTP status code defines its class:

  • 1xx – informational (request received, processing continues),
  • 2xx – success (e.g. 200 OK),
  • 3xx – redirection: the client has to take an extra step to get the resource,
  • 4xx – client error (e.g. 404, 410) – more in my post on 404, 410 and other 4xx errors,
  • 5xx – server error (e.g. 500, 503) – I cover them in my post on 5xx codes.

A redirect always consists of two parts: a 3xx code and a Location header with the new address. The browser (or Googlebot) reads the header and sends another request – this time to the new URL. Users usually don’t notice any difference between the codes; the difference matters to search engines, caches and applications that submit forms.

What exactly does the client do when it gets a 3xx code with a Location header? According to RFC 9110, it sends the same request again, but to the new address. The URL in Location can be relative (e.g. /new-page/), in which case the client resolves it against the original URL. Along the way it replaces headers that depend on the address (e.g. Host) and drops ones tied to the specific resource, such as Referer, Cookie or Authorization, generating them afresh for the new address. If the method has changed to GET, the request body (e.g. form data) is dropped too. Finally, the specification recommends that clients detect redirect loops; its earlier version recommended a limit of five hops, and some software still has one.

Why four ‘almost identical’ codes? In HTTP/1.0 (RFC 1945, 1996), the 301 and 302 codes were supposed to preserve the request method. Browsers, however, started fetching the new address with GET after redirecting a form sent with POST – and that practice stuck. So HTTP/1.1 (RFC 2068 and RFC 2616) added 303 (explicitly ‘switch to GET’) and 307 (temporary, no method change), and in 2014 came 308 (permanent, no method change; first as an experiment in RFC 7238, then as a standard in RFC 7538 in 2015). Today all 3xx codes are described in RFC 9110 (2022), which explicitly allows POST to change to GET with 301 and 302 ‘for historical reasons’.

Method may change (POST → GET)Method must stay the same
Permanent301 Moved Permanently308 Permanent Redirect
Temporary302 Found307 Temporary Redirect

301 vs 308 status code – permanent redirects

Both codes mean the same thing: the resource has a new, permanent address and all future references should use the new URL. The only difference is the method: with a 308 the client has to repeat the request with exactly the same method (a POST with form data reaches the new address as a POST), whereas with a 301 it may switch to GET.

The SEO impact is identical. Google’s documentation on HTTP status codes says outright that a 308 is equivalent to a 301: the crawler follows the redirect, and the indexing systems treat it as a strong signal that the target URL is canonical. Over time the old URL is replaced by the new one in the search results, and signals (including links) are consolidated on the target URL. The once-popular claim that a 301 ‘loses 10–15% of its power’ is out of date – since 2016 Google has said that 3xx redirects don’t cause any loss of PageRank.

Typical situations where you use a permanent redirect:

  • changing the site’s domain,
  • moving from HTTP to HTTPS,
  • changing the URL structure (e.g. from /post?id=123 to /article-name/) or changing a slug,
  • merging several similar articles into one more complete one,
  • standardising the domain version (with or without www).

Which one should you use? For ordinary pages a 301 is the default and entirely correct choice – it’s the one supported by every tool, plugin and hosting control panel. A 308 is better where the old address may receive POST, PUT or DELETE requests (APIs, form endpoints). And you don’t need to fix anything if your platform sets a 308 on its own – Next.js, for example, does this for redirects with permanent: true (and sends a 307 for temporary ones). For Google it makes no difference.

One thing worth remembering with both codes: the browser can remember them and not ask the server at all on the next visit. More on this in the section on 3xx codes and caching.

302 vs 307 status code – temporary redirects

A 302 redirect (Found, ‘Moved Temporarily’ in HTTP/1.0) says the resource is temporarily at a different address and the client should keep using the original one. A 307 redirect (Temporary Redirect) means the same, but with a strict requirement: the browser mustn’t change the request method. RFC 9110 even includes a note on 302: if changing POST to GET is undesirable, use 307.

For Google, a 307 is equivalent to a 302. Googlebot follows a temporary redirect, but the indexing system treats it only as a weak canonicalisation signal – the source URL usually stays in the results. The target URL may still get indexed, though, if other signals point to it (links, canonical, sitemap).

And what about a 302 that’s been ‘temporary’ for two years? Google assesses redirects in context: John Mueller has said many times that a long-standing 302 may be treated as permanent, because Google concludes the site owner mixed up the codes. There’s no defined point at which this happens, though, so don’t base your strategy on it. If the change is permanent, set a 301 – it’s the simplest way to make Google understand your intentions.

When a temporary redirect is the right choice:

  • maintenance or a service outage – you send users to an information page, and the original URL should stay in the results,
  • a short-term promotion or a seasonal version of a page,
  • A/B tests with separate URLs for the variants – Google’s testing guidelines recommend a 302 rather than a 301 in this case,
  • redirects that depend on the user’s state (e.g. not logged in → login page).

Be careful with automatic redirects based on browser language or IP location: Googlebot crawls mainly from US addresses, so it may never see your Polish or German versions. It’s better to show users a banner letting them choose a version and to mark up the variants with hreflang attributes.

When should you choose a 307 over a 302? When forms or API calls hit the temporarily moved address and the data from a POST request mustn’t get lost on the way. For ordinary pages the two codes work the same.

I show how to set up a 302 or 307 redirect in .htaccess, Nginx or PHP in my guide on how to set up a 301 redirect. In server rules usually only the number changes (e.g. R=301 to R=302).

303 See Other – the redirect after a form submission

A 303 code says: ‘you’ll find the result of your request at another address – fetch it with GET’. It doesn’t mean the resource has moved; the new address isn’t considered equivalent to the old one. The typical example is the Post/Redirect/Get pattern: the user submits a form (POST), the server saves the data and responds with a 303 pointing to a ‘Thank you’ page, and the browser fetches it with GET. That way refreshing the page doesn’t resubmit the form. Here’s what that exchange looks like in short:

POST /order/ HTTP/1.1
Host: shop.example

HTTP/1.1 303 See Other
Location: /order/thank-you/

GET /order/thank-you/ HTTP/1.1
Host: shop.example

How does a 303 differ from a 302 and a 307? With a 303 the next request is always a GET (or HEAD), whatever the original method, and the new address isn’t an equivalent of the old one, just the place where the result of the operation lives. With a 307 the method has to stay the same, and with a 302 browsers in practice switch POST to GET anyway. A 303 can also be a response to an ordinary GET request. In that case it means the server doesn’t have the resource itself but points to a page that describes it. You’ll mainly come across this pattern in Linked Data projects.

From an SEO point of view a 303 is a temporary redirect – Google lists it in the same group as 302 and 307. Don’t use it to move content. A 303 redirect is a tool for application developers, not SEO specialists.

304 Not Modified – caching, not a redirect

The 304 code belongs to the 3xx class, but it doesn’t redirect anyone anywhere. It’s a response to a conditional request: the browser or crawler already has a copy of the resource and asks the server whether anything has changed – by sending an If-None-Match header (with the ETag value) or If-Modified-Since (with the Last-Modified date). If the resource is the same, the server responds with a 304 and no body, and the client uses its cached copy. This saves time and bandwidth.

For Google, a 304 means ‘the content is the same as the last time it was crawled’. According to the documentation, the code doesn’t affect indexing (the system may only recalculate signals for the URL), but it takes load off the server when large sites are crawled frequently. That’s why working ETag and Last-Modified headers are one of the simpler ways to look after your crawl budget. Watch out for misconfiguration: a server that responds with a 304 to requests without conditional headers sends the crawler an empty response – and that can knock a page out of the index.

3xx codes and caching

3xx codes differ not only in permanence and method, but also in whether a browser or an intermediary server may store them without asking the server. The HTTP specification (RFC 9110) calls 300, 301 and 308 responses heuristically cacheable. This means that if the server doesn’t send Cache-Control or Expires headers, a cache may estimate on its own how long to keep such a response. 302, 303 and 307 don’t have this property and are only stored when the server explicitly allows it.

CodeCan it be cached without headers?What it means in practice
301, 308Yes (heuristically)The browser may remember the redirect even after you’ve removed the rule from the server.
300Yes (heuristically)Irrelevant in practice, because hardly anyone uses the code.
302, 303, 307No, only with Cache-Control or ExpiresOn the next visit the client asks the server again, so a changed or removed rule takes effect straight away.
304Not applicableIt’s the answer to a question about whether a copy already in the cache is still fresh.

Hence a practical tip: a 301 set up ‘just for a moment, for testing’ can be hard to undo, because for people who have already seen it, it may keep working. If you’re not sure the change is final, start with a 302. You can also send a Cache-Control header with a short lifetime (e.g. max-age=3600) along with the 301. And when you test redirects yourself, do it in an incognito window or with curl -I, which doesn’t remember anything.

300, 305 and 306 – codes you won’t come across in practice

  • 300 Multiple Choices – the resource has several representations (e.g. different formats or languages), and the server gives the client a list to choose from. There’s no standardised format for that list, so the code never really caught on.
  • 305 Use Proxy – was meant to require fetching the resource through a specified proxy. It was deprecated in RFC 7231, partly for security reasons – it let the server force an intermediary on the client.
  • 306 (Unused) – a number from an earlier version of the specification (the ‘Switch Proxy’ draft), now unused and reserved. It never came into widespread use.

‘307 Internal Redirect’ in Chrome – in other words, HSTS

If you open an address starting with http:// in Chrome and see 307 Internal Redirect in the Network tab of DevTools, it most likely wasn’t your server that sent that code. The browser itself changed the address to https://, because the domain uses HSTS (HTTP Strict Transport Security).

It works like this: in an HTTPS response the server sends a Strict-Transport-Security header with a validity period (max-age). The browser remembers that it may only connect to this domain over HTTPS, and on every subsequent attempt to visit over HTTP it rewrites the address locally – before any request goes out to the network. The same happens for domains on the HSTS preload list built into browsers (including entire top-level domains such as .dev or .app). DevTools presents this operation as a 307 response with a Non-Authoritative-Reason: HSTS header – ‘non-authoritative’ because it doesn’t come from the server.

What this means in practice:

  • It isn’t an error and doesn’t affect SEO. Neither Googlebot nor other tools see this ‘redirect’ – it’s a browser security mechanism.
  • It doesn’t replace a server-side redirect. HSTS only kicks in after the first visit over HTTPS (or thanks to the preload list), and only in browsers. A server-side 301 redirect from HTTP to HTTPS is still needed for crawlers, old links and new users.
  • Want to see what the server really returns? Check the http:// address with curl -I (curl doesn’t apply HSTS by default) or an external redirect checker. In Chrome itself you can view or delete a domain’s HSTS entry at chrome://net-internals/#hsts (this doesn’t apply to domains on the preload list).

Redirect chains and loops

A redirect chain happens when URL A redirects to B, B to C and so on. By default Googlebot follows up to 10 redirects, but every hop adds delay. A redirect loop is when A leads to B and B back to A. The browser breaks it off with a ‘Too many redirects’ message (ERR_TOO_MANY_REDIRECTS), and the page is unavailable to Google as well.

Where they come from and how to fix them, with rules that redirect to HTTPS and the non-www version in a single hop, is covered in my guide on how to set up a 301 redirect. You can check the status codes of thousands of URLs at once with a simple Python script.

FAQ – 3xx codes

Does a 302 status code pass SEO value?

Google doesn’t ‘cut’ PageRank on any 3xx redirect. The difference is which URL is treated as canonical: with 302 and 307 it’s usually the source URL, so that’s the one that collects the signals and appears in the results. If you want the target URL in the results, use a 301 or 308.

Which is better for SEO: 301 or 308?

Neither. Google treats a 308 exactly the same as a 301. The choice depends on whether the old URL receives requests other than GET – if it does, a 308 is safer, because it preserves the method and the request body.

What’s the difference between a 307 and a 302 status code?

Both are temporary and equivalent for Google. A 307 forbids the browser from changing the request method (a POST has to stay a POST), while a 302 – ‘for historical reasons’ – allows that change. If you only see a 307 code in Chrome when visiting an http:// address, it’s an internal HSTS redirect, not a response from your server.

Is a 3xx code in Google Search Console an error?

No. The ‘Page with redirect’ status in the indexing report simply means Google isn’t indexing the source URL but the target – which is how it should be. The real problems are redirects in your sitemap and internal links, chains, loops, and 302s where the change is permanent.

Is a 308 code an error?

No. 308 Permanent Redirect is an ordinary permanent redirect, the equivalent of a 301 that preserves the request method. If a tool flags it as an ‘error’, it usually just means the page doesn’t respond with a 200 straight away. Check where the Location header leads and whether a chain or loop has formed. Very old software may not recognise 308, because it’s the youngest code in the class (2014).

Do browsers remember redirects?

They can. According to the specification, 301 and 308 responses are heuristically cacheable, so a browser may remember them even without Cache-Control headers. It will only store a 302, 303 or 307 if the server allows it. That’s why you should test changes to redirects in an incognito window or with curl -I.

Can 304 Not Modified harm a site?

Used correctly – no, it actually helps, because it reduces server load. Only a misconfiguration does harm: when the server returns a 304 without checking the conditional headers, or for a resource that has actually changed – then the crawler and users get outdated or empty content.

3xx codes in a nutshell

  • 301 – a permanent change of address for an ordinary page. The default choice for migrations, slug changes, HTTPS and merging content.
  • 308 – a permanent change when you need to preserve the request method (APIs, forms). For Google, the same as a 301.
  • 302 – a temporary change: maintenance, a promotion, an A/B test. The old URL stays in the results.
  • 307 – a temporary change that preserves the method. For Google, the same as a 302; in Chrome you also see it with HSTS.
  • 303 – a redirect after a form submission, not for moving content.
  • 304 – not a redirect but a cache response; you configure it with ETag and Last-Modified.
  • 300, 305, 306 – unused in practice (305 deprecated, 306 reserved).

Choosing the right code is half the battle – the other half is implementing it correctly, without chains and loops. You’ll find ready-made rules for Apache, Nginx, PHP, WordPress and Cloudflare in my guide on how to set up a 301 redirect. And if your site has been through several migrations and you don’t know how many old rules overlap, I’ll check it as part of an SEO audit: a crawl of the whole site reveals chains, loops and internal links that go through redirects.

Tomasz Stopka

Tomasz Stopka

SEO consultant since 2008 · published author on content marketing

I have worked at agencies, at Onet (one of Poland’s largest web portals) and independently as SEMURAI. In the Academy I share what has worked in practice – specific and no fluff.

Read next