308 Permanent Redirect

TL;DR — A 308 Permanent RedirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. says “this moved for good” — exactly like a 301 — but with one extra promise: the request method can’t be changed at the new address, and because the browser repeats the same request rather than a new one, the rest of it (including a form’s data) normally travels along too. So a form submission stays a form submission instead of quietly turning into a plain page visit. For search engines the two codes are identical, so for a normal “this page moved” redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. a 301 is fine. Reach for a 308 when you’re redirecting something that isn’t just a page someone clicks — like an API or a form — and the original request has to arrive intact.

What a 308 actually is

When a server sends your browser from one URL to another, it stamps the response with a number — a status code. A couple of those numbers mean “this page has permanently moved”:

• 301 — “Moved Permanently.” The original, oldest permanent-redirect code. It’s been around since the early web.
• 308 — “Permanent Redirect.” A newer code (added to the spec in 2015) that does the same job plus one guarantee the 301 never made.

That guarantee is the whole reason 308 exists. Most of the time, when you visit a page, your browser sends a simple request called a GET — “please give me this page.” But when you submit a form or log in, your browser sends a POST — a request that carries data (the stuff you typed). With an old-style 301, the browser is technically allowed to turn your POST into a plain GET on the way to the new URL — which usually means that data gets dropped. A 308 isn’t allowed to change the method that way. Because the browser is repeating the same request instead of making a new one, the data normally comes along with it — but if that matters for something you’re building (an API call, a checkout flow), don’t just take the spec’s word for it: test the actual request and confirm the body arrives at the new URL.

Does a 308 hurt SEO?

No. Google’s own documentation literally says a 308 is “Equivalent to 301.” Both are permanent redirects, and both pass a page’s ranking signals forward to the new URL the same way. Bing treats them the same too. There is no ranking bonus for using a 308, and no penalty either — the choice between them is about the technical behavior above, not about search rankings. Evidence for this claim Google treats 308 as equivalent to 301 for Search and groups both as permanent redirects. Scope: Google Search processing; the two status codes remain semantically different for HTTP clients. Confidence: high · Verified: 2026-07-14 Google: HTTP status codes and Search Google: Redirects and Google Search

So when should you use one?

For a normal page that moved — a new URL, a switch from http to https, a domain change — a plain 301 is the easy, universal choice. Every browser, plugin, and hosting tool understands it.

Use a 308 specifically when the thing you’re redirecting isn’t a plain page:

• An API that other software calls.
• A form or login that sends data.
• A webhook — an automated URL another service posts to.

In those cases you can’t afford to have the request quietly downgraded and the data dropped, and a 308 guarantees it won’t be.

Want the spec history, the exact quotes from Google and Bing, and copy-paste server snippets? Switch to the Advanced tab.

TL;DR — A 308 is the permanent, strictly method-preserving redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't.: same canonicalizationHow search engines pick one canonical URL among duplicates and consolidate signals onto it. signal as a 301 (Google’s docs say “Equivalent to 301”), but it guarantees the client does not change the method at the new URL — and because a compliant client repeats the same request rather than a new one, the body travels along with it. It exists because HTTP had a temporary method-preserving code (307) years before it had a permanent one — RFC 7538 (2015) filled that gap, and RFC 9110 now points to 308 directly from its own 301 definition. For SEO the two are interchangeable (Illyes: Google “merges” 308 with 301; Bing’s Canel confirms parity). Reach for 308 when a non-GET request must survive: API/version migrations, webhook URLs, auth/form POST flows — but verify method and body preservation against your own client rather than assuming it from the spec alone. Otherwise 301 stays the default — browser support for 308 is strong in 2026 (caniuse currently tracks ~96.5%+), but RFC 9110 itself still flags 308 as younger and not universally recognized, and some CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. plugins, edge-rule UIs, and legacy proxies still only expose 301/302/307.

What 308 means, mechanically

A 308 Permanent RedirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. carries the same message as a 301 — this resource lives at a new URL now, permanently — with one addition the 301 never guaranteed: the client must not change the request method at the target. Because the client is repeating the same request rather than issuing a new one, the body travels along with it for a spec-compliant client — that’s a consequence of the method guarantee, not a separately certified promise, so treat it as something to verify end-to-end for your own client and server rather than assume outright. MDN describes 308 as the code that keeps the request method (and, in practice, the body) unchanged across the redirect, where a 301 may not.

The plain-English version I use in Ahrefs’ redirects guide: “A 308 redirect is the same as a 301 redirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank., except it retains the HTTP method of the original request, GET or POST, when performing the redirect.” Or, even shorter, in the HTTP status codes guide: “308 Permanent Redirect – Has the same functionality as a 301 redirect, except you can’t switch between POST and GET.” Evidence for this claim RFC 7538 defines 308 Permanent Redirect as a permanent move whose redirect follow-up must not change the request method. Scope: HTTP semantics for 308 responses. Confidence: high · Verified: 2026-07-14 IETF: RFC 7538 §3 — 308 Permanent Redirect

Here’s the difference made concrete. Say a client POSTs an order to /api/orders with a JSON body:

POST /api/orders HTTP/1.1
Host: shop.example.com
Content-Type: application/json

{ "sku": "A-100", "qty": 2 }

If that endpoint answers with a 301 and the client honors the legacy “you may switch to GET” allowance, the request can arrive at the new URL as an empty GET — the body gone, the order lost. Answer with a 308 and the client must repeat the POST at the new URL; a compliant client carries the body along with it, so the order goes through — confirm that against your own client and server logsLog file analysis is reading a web server's raw access logs to see exactly which URLs search engine crawlers actually requested, when, how often, and what status code they got. Unlike crawl tools or Search Console, logs are the unsampled, ground-truth record of what really happened. (see the Scripts tab) rather than assuming it universally. That’s the entire practical distinction: it only surfaces when the original request wasn’t a plain GET.

Why 308 exists — the spec history

This is the part most explainers skip, and it’s the cleanest way to understand the code.

307 came first. HTTP already had a temporary, method-preserving redirect — the 307 — well before it had a permanent equivalent. The original core spec (RFC 7231) never defined a permanent counterpart to 307. So there was a temporary “keep the method” code and a permanent “you may change the method” code (301), but no permanent “keep the method” code.

RFC 7538 filled the gap. 308 was added specifically to be the missing permanent 307 — first as experimental RFC 7238 (June 2014), then standardized as RFC 7538 (April 2015). It’s a plug for a real hole, not a replacement for 301.

The current spec points straight at it. RFC 9110, today’s HTTP semantics spec, still documents 301’s built-in ambiguity — and then names 308 as the fix, inside its own definition of 301: a user agentA user agent is the HTTP request header a client (browser, crawler, or bot) sends to identify itself. For crawlers, a short user-agent token — a substring of that string — is what robots.txt rules actually target. “MAY change the request method from POST to GET for the subsequent request… If this behavior is undesired, the 308 (Permanent Redirect) status code can be used instead.” That single sentence is the whole reason 308 exists, straight from the authoritative spec. And in its own 308 section, RFC 9110 adds the one honest caveat: this code “is much younger (June 2014) than its sibling codes and thus might not be recognized everywhere.”

So 301’s POST-to-GET behavior isn’t a bug — it’s a documented “for historical reasons” allowance baked into the spec, and 308 is the officially blessed way to opt out of it.

301 vs 308 — the practical difference in one table

The takeaway: for the overwhelming majority of redirects — which are plain GETs — a 301 and a 308 do the exact same thing. The guarantee only earns its keep when a non-GET method with a body is in play. (For the full head-to-head, see the dedicated 301-vs-308 comparison.)

Does Google treat 308 the same as 301 for SEO?

Yes, unambiguously, and it’s documented. Google’s HTTP status codes doc lists 301 as a redirect Google “use[s]… as a strong signal that the redirect target should be processed,” and lists 308 as simply “Equivalent to 301.” It adds a sensible caveat: “While Google treats these status codes the same way, keep in mind that they’re semantically different. Use the status code that’s appropriate for the redirect so other clients (for example, e-readers, other search engines) may benefit from it.” In plain terms — Google won’t punish you for using the “wrong” one, but you should still use the one that’s correct for the request, because other software relies on the distinction.

Google’s redirects doc puts both codes in the same recommended tier: “The 301 and 308 status codes mean that a page has permanently moved to a new location.” And its site-move guidance names 308 explicitly rather than treating it as a 301 afterthought — the recommendation is to use permanent HTTP redirectsA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. “such as 301 and 308” when doing a permanent move.

Worth knowing: this parity wasn’t always documented. Gary Illyes has said Google merges 308 into 301 internally, and Search Engine Roundtable’s coverage frames the moment it hit the official docs as the point an informal aside finally became something you could rely on — site owners who asked “is this actually documented?” a few years back were right to be cautious even though the underlying behavior never changed. If you want the exact wording from Google and its reps, the Quotes tab has the verified pull-quotes and deep links.

Does Bing treat 308 the same as 301?

Yes. Bing doesn’t have a dedicated docs page spelling out 308 the way Google does, but Microsoft’s Fabrice Canel confirmed it directly on X in September 2024, as reported by Search Engine Roundtable: Bing treats 308 redirects the same as 301 redirects. That’s the authoritative Bing statement — see the Quotes tab for the verbatim line.

When to actually use a 308

This is where the standalone case for 308 lives — and it’s almost always a non-GET request.

API endpoint and version migrations. Moving /v1/ to /v2/, or relocating an API host, is the textbook case. Clients hit these endpoints with POST/PUT/PATCH/DELETE and real bodies. A 308 guarantees the method and payload survive the hop; a 301 risks a silent downgrade that strands the request.

POST-heavy site migrationsA site migration is any significant change to a website's URL structure, domain, platform, protocol, or hosting that can affect how search engines crawl, index, and rank it. The risk scales with how much you change at once.. Checkout flows, login/auth endpoints, and form-action targets all POST data. If any of those URLs move during a migration, a 308 keeps the submission intact where a 301 might not.

Webhook URL changes. When another service POSTs to a webhook URL you’re relocating, a 308 tells its HTTP client to re-POST to the new address with the body intact — exactly what a webhook consumer needs.

The common thread: use a 308 wherever losing the body or having the method silently drop to GET would break functionality, not just shuffle a little SEO value.

Before you flip the switch on any of these, test it like an integration, not just a status code:

• Replay the real method and payload against a staging copy of the new endpoint.
• Confirm whether authorization headers or cookies are supposed to carry over, and check that they actually do.
• If the original request isn’t idempotent (a POST that creates an order, for example), watch for duplicate side effects during the redirect hop.
• Confirm the query stringThe `?key=value` data tacked onto the end of a URL after a question mark — used for tracking, sessions, filtering, sorting, and search — and one of the biggest sources of duplicate URLs and wasted crawling in SEO. and Content-Type header survive, not just the body.
• Verify the actual client — the webhook sender, the API SDK, the browser — automatically follows a 308 before you retire the old endpoint. Not every HTTP client does this by default.

When 301 is still the pragmatic default

For everything that’s a plain GET, 301 remains the sensible default:

• Ordinary content/page URL changes.
• HTTP → HTTPS migrationsAn HTTP to HTTPS migration is the process of moving every URL on a site from the insecure http:// scheme to the encrypted https:// scheme — installing a TLS certificate and 301-redirecting each old URL to its secure equivalent. Done correctly, it doesn't lose rankings or PageRank..
• Domain changes and standard site migrationsA site migration is any significant change to a website's URL structure, domain, platform, protocol, or hosting that can affect how search engines crawl, index, and rank it. The risk scales with how much you change at once..
• Trailing-slash and www/non-www normalization.

Here the request is a plain GET, so 308’s guarantee buys you nothing — and 301 wins on universality. There’s no SEO cost to either. Don’t mass-migrate existing 301s to 308s chasing a rankings bump; that upside doesn’t exist. Note that in the redirect-preference hierarchy from Ahrefs’ redirects guide, 308 and 301 sit together at the very top tier (ahead of meta refresh, JavaScript, and other workarounds) — they’re peers, not a ladder.

Adoption and support caveats — what’s actually a risk in 2026

Browser support is not the practical risk it once was. Per caniuse’s current tracking, 308 sits around 96.5%+ global support — check the live table for today’s number, since it shifts — and the visible gaps are concentrated in browsers that have been dead for years: pre-IE11, ancient Chrome/Firefox/Safari, old Android Browser. If you still see the old “IE11 fails on 308” warning floating around, it’s stale for mainstream traffic.

Tooling is the more current caveat. The honest, current-in-2026 gap is that not every layer exposes a 308 option. Some CMS redirect plugins, some CDN/edge redirect-rule UIs, and some older reverse proxies or load balancers still only let you pick 301/302/307. Before you commit to 308, verify the layer that actually serves the redirect can emit it rather than silently downgrading it — the Scripts tab has a one-liner to confirm the real status code on the wire. RFC 9110’s own “much younger… might not be recognized everywhere” note isn’t scoped only to browsers — it’s the spec’s general deployment caution for 308. In 2026 the practical bite of that caution shows up mostly in tooling rather than mainstream browsers, but it’s worth reading as the spec’s baseline caveat rather than something fully retired.

A non-standard footnote: “308 Resume Incomplete”

One quirk that underlines how young this code still is: 308 isn’t only a redirect code in the wild. Google Drive’s upload API reuses 308 with an entirely different meaning — “Resume Incomplete,” signaling that a chunked upload stalled and the client should resume. John Mueller flagged this himself (see the Quotes tab), and MDN documents the same non-standard usage. It doesn’t change anything about 308-as-a-redirect, but it’s a neat illustration that 308 is a newer, less culturally “settled” status code than the venerable 301.

Redirect chains and hops apply the same either way

None of the above changes how redirect chainsA → B → C instead of A → C. Each hop loses link equity and adds latency. work. Google’s crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. follow up to 10 redirect hops by default — though that’s a default, not a universal constant; Google’s own docs note specific products can differ (its URL Inspection toolA Google Search Console feature that reports how Google sees one specific URL on a property you own. By default it shows the last-indexed snapshot; a separate \"Test live URL\" mode fetches the current version., for example, doesn’t follow redirects at all), so check the current figure on Google’s docs rather than treating 10 as fixed forever. That default limit is identical whether the hops are 301s or 308s. If you’re stacking redirects (say, an old API path that hops twice before landing), the same chain-and-loop hygiene applies — collapse chains to a single hop where you can. See the dedicated redirect-chains piece for the mechanics.

AI summary

A condensed take on the Advanced version:

• 308 = permanent + strictly method-preserving. Same “moved permanently” message as a 301, plus a guarantee the 301 never made: the client must not change the request method at the new URL. A compliant client repeats the same request, so the body travels along with it — verify that end-to-end for your own client rather than assuming it from the spec alone.
• SEO-equivalent to 301. Google’s docs say 308 is “Equivalent to 301”; Gary Illyes says Google merges 308 into 301; Bing’s Fabrice Canel confirms Bing treats them the same. No ranking upside or penalty either way. (Attribution: those Illyes/Mueller/ Canel statements are relayed via Search Engine Roundtable — confirm against the original before treating as final.)
• Why it exists: HTTP had a temporary method-preserving redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. (307) years before it had a permanent one. RFC 7538 (2015) filled the gap. RFC 9110 points to 308 from its own 301 definition: a 301 “MAY change the request method from POST to GET… for historical reasons,” and “if this behavior is undesired, the 308… can be used instead.”
• Use 308 for: API/version migrations, webhook URL moves, form/auth POST flows — anywhere a dropped method/body would break functionality. Before switching, replay the real method and payload in staging and confirm auth headers, idempotency, and the actual client’s redirect-following behavior.
• Use 301 for: ordinary page moves, HTTP→HTTPSHTTPS is the encrypted version of HTTP — it uses TLS to authenticate the server and protect data in transit between a browser and a website. Google announced it as a lightweight ranking signal in 2014 and today conditionally prefers HTTPS pages as canonical; Chrome marks plain HTTP pages 'Not Secure.', domain changes, normalization — all plain GETs, where 308’s guarantee buys nothing and 301 wins on universal support.
• Adoption: browser support is strong (caniuse currently tracks ~96.5%+, gaps mostly in long-dead browsers), but RFC 9110 still carries a general “younger, might not be recognized everywhere” caveat for 308 — in 2026 that shows up mostly as a tooling gap (some CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. plugins, CDN/edge UIs, and legacy proxies only expose 301/302/307). Verify the redirect layer can actually emit 308, and note that 308 is heuristically cacheable, so a mistaken or rolled-back 308 can linger in caches.
• Footnote: Google Drive reuses “308 Resume Incomplete” for stalled uploads — a non-redirect use that shows how young the code still is.

Official documentation

Primary-source documentation on 308 from the search engines and the HTTP spec.

Google

• HTTP Status Codes, Network and DNS Errors, and Google Search — lists 308 as “Equivalent to 301,” the “semantically different, treated the same” caveat, and the 10-hop redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. limit.
• Redirects and Google Search — “The 301 and 308 status codes mean that a page has permanently moved to a new location.”
• Site moves with URL changes — recommends permanent HTTP redirectsA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. “such as 301 and 308” for a permanent move.

HTTP specification

• RFC 9110 — HTTP Semantics — the current spec. §15.4.9 defines 308 (and the “much younger… might not be recognized everywhere” caveat); §15.4.2 defines 301 and points to 308 as the fix for unwanted POST-to-GET conversion.
• RFC 7538 — HTTP Status Code 308 (Permanent Redirect) — the standard that introduced 308 (April 2015), obsoleting experimental RFC 7238 (June 2014).

Reference

• MDN — 308 Permanent Redirect — method/body-preservation semantics and the non-standard Google Drive “Resume Incomplete” usage.
• caniuse — HTTP status code 308 — the browser-support table (~96.5%+ global).

Quotes from the source

On-the-record statements from Google, Bing, and the HTTP spec. Each link deep-links to the quoted passage on the source page.

Google — the core equivalence

• “301 (moved permanently): Google follows the redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't., and Google systems use the redirect as a strong signal that the redirect target should be processed.” — Google Search Central docs. Jump to quote
• “308 (moved permanently): Equivalent to 301.” Jump to quote
• “While Google treats these status codes the same way, keep in mind that they’re semantically different. Use the status code that’s appropriate for the redirect so other clients (for example, e-readers, other search engines) may benefit from it.” Jump to quote
• “The 301 and 308 status codes mean that a page has permanently moved to a new location.” Jump to quote

Gary Illyes, Google

• On how Google handles a 308: “we just merge that with 301 so we really don’t care iirc.” Relayed via Search Engine Roundtable’s verbatim coverage, Google Officially Treats 308 Redirects As 301 Redirects (Jul 2021) — confirm against the original before treating as final.

John Mueller, Google

• On the non-standard usage: “Google Drive uses a 308 redirect as a Resume Incomplete response to indicate to the client when an incomplete upload stalled. So that is a bit different. But you can use it as a normal redirect.” Relayed via Search Engine Roundtable, Google Can Treat 308 Redirects As 301 Redirects (May 2018) — confirm against the original before treating as final.

Fabrice Canel, Microsoft Bing

• “I accidentally deleted my reply, so confirming again: Bing treats 308 redirects the same as 301 redirectsA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank..” Fabrice Canel on X (Sept 2024), relayed via Search Engine Roundtable, Bing Treats 308 Redirects The Same As 301 Redirects — confirm against the original before treating as final.

RFC 9110 — the HTTP semantics spec

• On why 308 exists, from the spec’s own definition of 301: “For historical reasons, a user agentA user agent is the HTTP request header a client (browser, crawler, or bot) sends to identify itself. For crawlers, a short user-agent token — a substring of that string — is what robots.txt rules actually target. MAY change the request method from POST to GET for the subsequent request. If this behavior is undesired, the 308 (Permanent Redirect) status code can be used instead.” Read RFC 9110
• On adoption: 308 “is much younger (June 2014) than its sibling codes and thus might not be recognized everywhere.” Read RFC 9110

Should this redirect be a 308?

Because 301 and 308 are SEO-equivalent, this isn’t a rankings decision — it comes down to one question: is a non-GET request with a body in play, and can your redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. layer actually emit a 308? Walk it through.

The short version: plain GET → 301; a non-GET request you must preserve (and your stack can emit it) → 308. For SEO the two are interchangeable, so the method question — plus a quick “can my tooling actually do it” check — is the only thing that decides it.

Myths and mistakes about 308

Pulled straight from the failure modes I see most often.

“308 is better for SEO than 301.” False. Google’s docs say “Equivalent to 301,” and Illyes, Mueller, and Bing’s Canel all confirm parity. No engine treats 308 as SEO-superior. Choosing it is about method/body correctness, never a rankings edge.

“You should migrate all your existing 301s to 308s.” Pure churn with zero ranking upside. If the redirected requests are plain GETs — the overwhelming majority of page-to-page redirectsA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. — a 301 already behaves identically in practice. Reserve the switch for redirects that actually carry non-GET methods.

“308 isn’t safe because it’s newer.” Overstated for browsers specifically: RFC 7538 is over a decade old, both Google and Bing confirm engine-level support, and caniuse currently shows ~96.5%+ browser support with gaps mostly in long-dead versions. RFC 9110 does still carry a general “younger, might not be recognized everywhere” caveat for 308 — in 2026 that shows up mostly as a tooling gap (not every CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. plugin, CDN redirect-rule UI, or legacy proxy exposes a 308 option) rather than a client or search-engine gap, but it’s not a caveat that’s fully retired.

“A 301 will always mangle my POST/API request.” Overstated. Many modern clients preserve behavior reasonably well; the real, spec-documented risk is the specific POST-to-GET conversion RFC 9110 allows “for historical reasons,” which bites when a client honors that legacy allowance. 308 removes the risk entirely — it doesn’t fix a guaranteed, universal failure.

“308 is only ever a redirect code.” Not quite. Google Drive’s non-standard “308 Resume Incomplete” reuses the code for a stalled upload — a different meaning entirely. It’s a good reminder that 308’s real-world usage is younger and less settled than 301’s.

Bonus contrast — “permanent redirectsA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. lose PageRankPageRank is Google's original recursive link-graph algorithm: a page's score depends on the scores of the pages linking to it, and in the published model each page's score is split across its outbound links (the simplified version: links are weighted votes). Google says it's evolved since launch but still part of its core ranking systems..” Not this article’s core topic, but worth a sentence: Google’s own guidance groups 301 and 308 together as permanent redirects it uses as a signal to process the new URL as the canonical target — that reads as continuity, not a value hit. Treat it as Google’s documented processing behavior rather than a blanket “no PageRankPageRank is Google's original recursive link-graph algorithm: a page's score depends on the scores of the pages linking to it, and in the published model each page's score is split across its outbound links (the simplified version: links are weighted votes). Google says it's evolved since launch but still part of its core ranking systems. is ever lost” guarantee; the narrower, canonical-signal framing is the one the current source actually supports.

Confirm and implement a 308

The single most useful thing you can do with 308 is verify the real status code on the wire — because the most common failure isn’t a browser problem, it’s a tooling layer silently downgrading your intended 308 to a 301 (or not emitting a redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. at all).

Check the status code with curl

# Show only the response headers; -I sends a HEAD request.
curl -sI https://example.com/old-path | head -n 1
# → HTTP/1.1 308 Permanent Redirect     (what you want)
# → HTTP/1.1 301 Moved Permanently      (your layer downgraded it)

To confirm the method is actually preserved on a POST (the whole point of a 308), follow the redirect with -L and watch what arrives — -X POST plus --data will only stay a POST across the hop if the server returned a 308/307:

curl -sIL -X POST --data '{"sku":"A-100"}' \
  -H 'Content-Type: application/json' \
  https://api.example.com/v1/orders
# Inspect each hop's request line; a 308 keeps it "POST", a 301 may show "GET".

Trace a whole chain

If the path hops more than once, print every status code in the chain so you can spot a downgrade or an unintended extra hop:

curl -sIL https://example.com/old-path \
  | grep -iE '^HTTP/'
# Each line is one hop. Collapse chains to a single hop where you can.

Check whether a 308 is cached before you roll it back

RFC 9110 makes 308 heuristically cacheable — a client or intermediary can decide to cache it even without an explicit Cache-Control header. That means a mistaken 308 (or one you need to reverse) can keep getting served from a cache well after you fix the origin rule. Before you conclude a redirect is “stuck”:

• Test with both a fresh client (private/incognito, no prior visit) and one that already hit the old URL — cached and uncached clients can behave differently.
• Check the response for Cache-Control, Expires, and Age headers with curl -sI.
• Test a plain GET and a representative non-GET request separately; cachingCaching stores a copy of a page or resource — in a browser, a CDN edge node, or a search crawler's own cache — so it can be served again without regenerating or re-downloading it. It isn't a direct ranking factor, but it feeds page speed and crawl efficiency. behavior can differ by method.
• If you need to roll a 308 back, purge the edge/CDN cache explicitly — don’t assume removing the origin rule is enough, and expect that some clients which already cached the old redirect won’t re-request it on their own.

Chrome DevTools Console — check a redirect from the browser

Paste into the DevTools Console (F12 → Console) to see the final URL and status without leaving the page. A manual-redirect fetch reports the first response’s status directly:

// Reports the status of the first response (the redirect itself), not the target.
fetch('https://example.com/old-path', { method: 'HEAD', redirect: 'manual' })
  .then(r => console.log('type:', r.type, 'status:', r.status || '(opaqueredirect)'));

// Follow the chain and log where it lands:
fetch('https://example.com/old-path', { method: 'HEAD', redirect: 'follow' })
  .then(r => console.log('final URL:', r.url, 'final status:', r.status));

Bookmarklet — one-click “what does this URL return?”

Drag a bookmark with this as its URL, then click it on any page to prompt for a URL and alert its final status and landing URL:

javascript:(function(){var u=prompt('URL to check:',location.href);if(!u)return;fetch(u,{method:'HEAD',redirect:'follow'}).then(function(r){alert('Final status: '+r.status+'\nLanded on: '+r.url);}).catch(function(e){alert('Error: '+e);});})();

Implement a 308 on the server

Apache (.htaccess) — mod_rewrite with an explicit R=308:

RewriteEngine On
RewriteRule ^old-path/?$ /new-path [R=308,L]

nginx — return 308 is exact and unambiguous:

location = /old-path {
    return 308 https://example.com/new-path;
}

Express.js (Node) — pass the status code to redirect():

app.all('/api/v1/orders', (req, res) => {
  // 308 keeps the POST body intact on the way to /api/v2/orders
  res.redirect(308, '/api/v2/orders');
});

Next.js — set permanent: true and it emits a 308 (Next’s permanent redirectsA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. are 308s):

// next.config.js
module.exports = {
  async redirects() {
    return [
      { source: '/api/v1/:path*', destination: '/api/v2/:path*', permanent: true },
    ];
  },
};

Framework and hosting-layer behavior isn’t fixed across versions. Next.js’s own redirect handling, for example, can differ by version and by where the redirect is triggered — a next.config.js redirects() entry, a permanentRedirect() call in a Server Action, or a streaming response don’t necessarily all resolve to the same status code. The same caution applies to Apache/nginx module versions and any CDN or proxy layer in front of your origin. Treat every snippet above as a starting point, not a guarantee, and confirm your own version’s current docs.

After deploying any of these, re-run the curl -sI check above to confirm the wire actually carries a 308 — that verification step is the one people skip and regret.

Tools for confirming a 308 on the wire

Patrick’s free tools

• Redirect Checker — trace one URL or a quick batch and confirm the first response is 308, the destination is correct, and the chain ends at a healthy final response.
• Bulk HTTP Status Code Checker — check up to 500 migrated URLs, filter unexpected 301/302/307 responses, and export chains or loops for remediation.

Prove the strict behavior when it matters

• curl with a safe test payload — replay the real method against a staging or non-destructive endpoint and follow the redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't.. Confirm the source emits 308.
• Application/API gateway logs — verify the target received the same method, content type, and body. A redirect checker proves the status and destination; receiving logs prove method preservation worked end to end.
• Browser DevTools Network panel — useful for form and auth flows, but separately test webhook and API clients because interoperability is the reason to choose 308 over 301.
• Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. URL InspectionA Google Search Console feature that reports how Google sees one specific URL on a property you own. By default it shows the last-indexed snapshot; a separate \"Test live URL\" mode fetches the current version. — for indexable page URLs, confirm the permanent move is processed like a 301 and that the destination is the selected canonical.

Test yourself: 308 Permanent Redirect

Five quick questions on what a 308 is, why it exists, and how the search engines treat it. Pick an answer for each, then check.

Resources worth your time

My writing

• 11 Types Of Redirects & Their SEO Impact (with Joshua Hardwick) — my definition of 308, the “for SEO purposes they’re the same, but forms” framing, and the redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't.-preference hierarchy where 308 and 301 share the top tier.
• HTTP Status Codes & Their SEO Impact — where I put it plainly: 308 “has the same functionality as a 301… except you can’t switch between POST and GET,” and 308s “are treated the same as 301s and consolidate forward.”
• A Website Migration Takes More Than A Checklist To Be Successful — why I reach for 301 or 308 (not 302/307) on a permanent move.
• The Beginner’s Guide to Technical SEO — where redirects fit in the bigger picture.

From around the industry

• Redirects and Google Search — Google’s official redirects guide, naming 301 and 308 together as the permanent options.
• HTTP Status Codes, Network and DNS Errors, and Google Search — the doc that calls 308 “Equivalent to 301” with the “semantically different” caveat.
• RFC 9110 — HTTP Semantics — the current spec; its 301 definition points to 308 as the fix for unwanted POST-to-GET conversion.
• RFC 7538 — HTTP Status Code 308 (Permanent Redirect) — the standard that introduced 308.
• MDN — 308 Permanent Redirect — method/body semantics and the Google Drive “Resume Incomplete” note.
• caniuse — HTTP status code 308 — the browser-support table debunking the “308 is fragile” myth.
• Bing Treats 308 Redirects The Same As 301 Redirects (Search Engine Roundtable) — Fabrice Canel’s 2024 confirmation for Bing.
• Google Officially Treats 308 Redirects As 301 Redirects (Search Engine Roundtable) — the Gary Illyes “we just merge that with 301” context and the “now it’s official” documentation moment.

308 Permanent Redirect

A 308 Permanent Redirect is the HTTP status code for a permanent move that strictly preserves the request method — a POST stays a POST — and, because a compliant client repeats the same request, the body normally travels with it. For SEO it's equivalent to a 301; the difference is the method guarantee, which matters for APIs, webhooks, and form/POST traffic.

Related: 301 redirect, 307 redirect

308 Permanent Redirect

A 308 Permanent RedirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. is an HTTP status codeAn HTTP status code is the three-digit number a server returns with every response to tell a browser or crawler what happened to its request — success, redirect, client error, or server error. For SEO the code matters as much as the content: it tells Google and Bing whether to index a page, follow a redirect, retry later, or drop the URL from the index. that tells a browser or crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. a resource has moved permanently to a new URL — the same permanence signal as a 301 — with one strict, spec-guaranteed difference: the client must not change the request method at the new location. A POST stays a POST; a GET stays a GET. Because the client repeats the same request rather than issuing a new one, the body normally travels along with it for a spec-compliant client — worth confirming for your own integration rather than assuming outright. In short, a 308 is a 301 that legally can’t turn your POST into a GET.

The code exists to fill a real hole in the HTTP spec. HTTP had a temporary, method-preserving redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. (307) years before it had a permanent one. RFC 7538 (April 2015; first published as experimental RFC 7238 in June 2014) added 308 as the missing permanent counterpart. The current HTTP semantics standard, RFC 9110, specifies that a user agentA user agent is the HTTP request header a client (browser, crawler, or bot) sends to identify itself. For crawlers, a short user-agent token — a substring of that string — is what robots.txt rules actually target. must not change the request method when automatically following a 308.

For Google Search, the answer is settled: its redirect documentation classifies both 301 and 308 as permanent server-side redirects. There’s no ranking upside or penalty either way. Reach for a 308 specifically when a non-GET request — an API call, webhook, or form POST — must arrive intact; otherwise a 301 stays the pragmatic default because of broader tooling, CDN, and plugin support.

Related: 301 redirect, 307 redirect

Changelog