A 308 redirect is a permanent HTTP status code that tells browsers and search engines that a resource has moved to a new location forever. Unlike other redirect types, the 308 redirect preserves the original request method and any associated data during the redirection process.
This comprehensive guide will help web developers and SEO professionals understand what a 308 redirect is, how it differs from other redirect status codes and when implementing this HTTP status code makes the most sense for your website architecture.
What is a 308 redirect?
The HTTP 308 status code represents a permanent redirect that maintains specific request characteristics during the redirection process. When a server returns a 308 response, it communicates three critical pieces of information to the requesting client.
First, the requested resource has permanently moved to a different location. The server provides the new URL in the Location header, indicating where the client should direct future requests for this resource. This permanent nature distinguishes it from temporary redirect options.
Second, the 308 redirect maintains the request method exactly as sent in the original request. If a client made a POST request to the original URL, the redirected request will also use the POST method. This preservation applies to all HTTP methods, including GET, POST, PUT, DELETE and PATCH requests.
- GET retrieves data.
- POST submits new data.
- PUT updates existing data.
- DELETE removes data from a server.
- PATCH partially updates existing data on a server.
Third, any request body data that accompanied the original request gets preserved during the redirect process. This characteristic proves particularly valuable for web applications that handle form submissions, API calls or file uploads, where losing the original data would break functionality.
A 308 permanent redirect tells browsers and other HTTP clients to resend the same request to the new location while preserving the original method, headers and request body. Search engines interpret this status code as a signal to update their indexes with the new URL while transferring ranking signals from the old location.
308 vs 301 redirect differences
Understanding the distinction between 308 redirect vs 301 redirect helps determine which status code best fits your specific use case. Both represent permanent redirects, but they handle request methods and data differently.
A 301 redirect allows browsers to change the request method during redirection. Browsers convert POST requests into GET requests when following a 301 redirect, which can result in the original request data being lost. This behavior follows historical browser implementations and HTTP specifications that permit method changes for certain redirect types.
The 308 redirect strictly preserves the original request method without any modifications. When a client receives a 308 response, it must maintain the exact same HTTP method for the redirected request. This preservation ensures that POST requests remain POST requests. PUT requests stay PUT requests. The same applies to all other HTTP methods.
Request body handling represents another key difference between these redirect status codes. With 301 redirects, browsers typically discard request body data when converting methods. Since most 301 redirects result in GET requests, the original POST data gets lost during the process.
The 308 redirect maintains all request body data throughout the redirection process. This preservation proves essential for applications that cannot afford to lose form submissions, API payloads or uploaded files during redirect operations.
For temporary redirects, the same pattern applies: 302 behaves like the temporary version of 301, while 307 behaves like the temporary version of 308. A 302 redirect is used for temporary page moves but does not guarantee method preservation. A 307 redirect is also temporary, but it preserves the original request method and request body, making it safer for temporary form, upload or API redirects.
Search engine behavior remains similar for both status codes. Google and other search engines treat both 301 and 308 redirects as permanent moves, transferring PageRank and other ranking signals to the new URL. The choice between them primarily affects how browsers handle the redirect rather than search engine interpretation.
When to use a 308 redirect
Implementing a 308 redirect becomes the optimal choice when your website or application needs to preserve request methods and data during permanent URL changes.
| Redirect | Permanent | Preserves method | Common use case |
|---|---|---|---|
| 301 | Yes | No | Standard page redirects |
| 308 | Yes | Yes | APIs, forms, uploads |
Real-world examples:
Choosing between a 301 and a 308 redirect is not about SEO; it’s about how the request behaves after the redirect. In many cases, using the wrong one can break functionality.
1. Form submissions (contact forms, checkout flows)
Scenario:A user submits a form via POST to:
/submit-form
You move this endpoint to:
/api/forms/submit
Correct choice: 308 redirect
- The POST request is preserved.
- The form data is sent to the new endpoint.
- Submission works as expected.
If you use a 301 instead:
- The POST request may be converted to a GET.
- The request body (form data) is dropped.
- The server receives an empty request.
What breaks:
- Form submissions fail silently or return errors.
- Users may see a success page without data actually being processed.
- Leads, messages or transactions are lost.
2. API endpoints (REST APIs)
Scenario:An API endpoint moves from:
POST /api/v1/orders
to:
POST /api/v2/orders
Correct choice: 308 redirect
- The POST method is preserved.
- The JSON payload is preserved.
- The API continues working without changes to clients.
If you use a 301 instead:
- The request may become:
GET /api/v2/orders
What breaks:
- API returns 405 Method Not Allowed.
- Data is never created or updated.
- Clients fail unexpectedly (especially third-party integrations).
3. File uploads
Scenario:Users upload files to:
POST /upload
You move uploads to:
POST /files/upload
Correct choice: 308 redirect
- File data is preserved.
- Upload continues to the new endpoint.
- No user interruption.
If you use a 301 instead:
- The request may become GET.
- File data is dropped.
What breaks:
- Upload fails completely.
- Users must retry.
- Large uploads are lost, causing frustration.
4. Payment processing/checkout flows
Scenario:Checkout endpoint moves:
POST /checkout → POST /payments/checkout
Correct choice: 308 redirect
- Payment data is preserved.
- Transaction completes correctly.
If you use a 301 instead:
- POST may become GET.
- Payment payload is lost.
What breaks:
- Transactions fail.
- Orders are not created.
- Potential revenue loss.
5. Standard page redirects (blog posts, landing pages)
Scenario: You move a page:
/blog/old-post → /blog/new-post
Correct choice: 301 redirect
- Simple GET request.
- No data or method to preserve.
- SEO signals transfer correctly.
If you use a 308 instead:
- Nothing breaks.
- But no real benefit is gained.
What to know:
- 308 is unnecessary here.
- 301 is simpler and widely expected.
6. Content migrations and site restructures
Scenario: Moving sections like:
/blog/* → /resources/*
Correct choice: 301 redirect
- Requests are GET.
- Focus is on SEO and URL structure.
If you use 308 instead:
- Works the same for GET.
- Adds no additional value.
How to implement a 308 redirect
Setting up a 308 redirect requires server-level configuration using various methods depending on your web server software and hosting environment. The implementation process involves configuring your server to return the appropriate status code and location header.
Apache implementation
Apache web servers support 308 redirects through .htaccess files or virtual host configurations. The mod_rewrite module provides the necessary functionality for implementing these redirects effectively. This approach offers flexibility for both simple and complex redirect scenarios.
```apache
RewriteEngine On
RewriteRule ^old-page$ /new-page [R=308,L]
```
For more complex pattern matching, Apache configurations can handle multiple URLs simultaneously. This method proves useful when restructuring entire website sections or migrating content in bulk operations.
```apache
RewriteEngine On
RewriteRule ^old-section/(.*)$ /new-section/$1 [R=308,L]
```
Nginx implementation
Nginx configurations use the return directive to implement 308 redirects within server blocks or location contexts. This approach provides clean, efficient redirect handling with minimal server overhead and fast response times.
```nginx
location /old-page {
return 308 /new-page;
}
```
For pattern-based redirects, Nginx supports regular expressions and variable substitution. This functionality enables dynamic redirect logic based on URL patterns or request characteristics.
```nginx
location ~* ^/old-section/(.+)$ {
return 308 /new-section/$1;
}
```
Application-level implementation
Many web frameworks provide built-in methods for returning 308 status codes programmatically. This approach offers dynamic redirect logic based on application state or user conditions. Application-level redirects provide greater flexibility for complex business logic requirements.
PHP implementations can use header functions to set the appropriate response. This method integrates well with existing PHP applications and content management systems.
```php
header("Location: https://example.com/new-page", true, 308);
exit();
```
Node.js applications using Express can implement 308 redirects through response methods. This approach works seamlessly with modern JavaScript applications and API services.
```javascript
app.get('/old-page', (req, res) => {
res.redirect(308, '/new-page');
});
```
SEO implications of 308 redirects
Search engines handle 308 redirects similarly to 301 redirects when indexing and ranking web pages. Google's documentation confirms that both status codes receive equal treatment for SEO purposes, with ranking signals transferring from old to new URLs. This equivalency ensures that website owners don't lose search engine optimization value during URL changes.
Page load speed considerations remain minimal for 308 redirects since they function as single HTTP responses. Search engine crawlers process these redirects efficiently without significant impacts on website performance metrics. The redirect response adds only minimal latency to the overall page loading process.
Link equity preservation works effectively with 308 implementations. Backlinks pointing to the old URL will pass their ranking value to the new destination, maintaining the SEO benefits accumulated over time. This transfer process helps websites maintain their search engine rankings during restructuring or migration projects.
Internal linking structures should be updated to point directly to new URLs rather than relying on redirects long-term. While 308 redirects preserve SEO value, direct links provide better user experiences and reduce server processing overhead. This optimization improves overall website performance and reduces unnecessary HTTP requests.
Sitemap updates become necessary when implementing permanent redirects. XML sitemaps should reflect the new URL structure to help search engines discover and index the correct pages efficiently. Updated sitemaps accelerate the indexing process and ensure search engines understand the current website structure.
Common implementation mistakes
Several frequent errors occur when implementing 308 redirects that can impact functionality and user experience. Understanding these pitfalls helps developers avoid problematic configurations and ensures smooth redirect operations.
Redirect chains create unnecessary complexity and slower page load speeds. When multiple redirects connect in sequence, browsers must follow each step individually, increasing the time required to reach the final destination. Each additional redirect adds latency and potential failure points to the user experience.
Incorrect status code selection leads to unexpected behavior. Using 301 redirects when request method preservation is required can break form submissions and API interactions. Similarly, temporary redirects (302, 307) don't signal permanent moves to search engines, which can negatively impact SEO performance and indexing decisions.
Missing or incorrect Location headers prevent proper redirect functionality. The destination URL must be properly formatted and accessible or browsers will display error messages instead of completing the redirect. Malformed URLs or inaccessible destinations create poor user experiences and broken website functionality.
Circular redirects create infinite loops that browsers eventually terminate with error messages. These occur when redirect configurations accidentally point back to the original URL or create closed loops between multiple URLs. Circular redirects prevent users from accessing content and can impact search engine crawling efficiency.
Protocol mismatches can cause security warnings in browsers. Redirecting from HTTPS to HTTP URLs triggers mixed content warnings and potentially exposes user data to security risks. These mismatches undermine user trust and can negatively impact website credibility and search engine rankings.
Testing and monitoring 308 redirects
Testing a 308 redirect is important because the redirect needs to do more than point to the right destination. It should return the correct status code, preserve the request method and avoid creating unnecessary chains or loops.
The easiest way to check this is with a redirect checker like urllo’s redirect checker. This lets you test URLs in bulk and review the full redirect path, including status codes, response times, request details and headers. This makes it easier to confirm that your 308 redirect is resolving correctly before it affects users, search engines or application workflows.
For technical validation, command-line tools like curl can also help confirm the response status and Location header:
curl -I -X POST https://example.com/old-page
You should also monitor redirects over time, especially after migrations, endpoint changes or infrastructure updates. A redirect that works on launch can later become part of a chain, point to the wrong destination or create a loop if new rules are added elsewhere. Regular testing helps catch those issues early and keeps redirects reliable, fast and easy to maintain.
Conclusion
The 308 redirect provides a powerful tool for web developers who need to permanently move resources while preserving request methods and data. Understanding when to use a 308 redirect instead of alternatives like 301 or 302 redirects ensures optimal functionality for web applications and APIs.
Proper implementation requires careful attention to server configuration, testing procedures and ongoing monitoring. By following best practices and avoiding common mistakes, developers can leverage 308 redirects to create seamless user experiences during website restructuring or URL changes. The implementation process demands thorough planning and consideration of various technical factors that influence redirect behavior.
The HTTP 308 status code fills an important gap in redirect functionality, offering the permanence of 301 redirects with the method preservation of 307 responses. This combination makes it ideal for modern web applications that rely heavily on non-GET request methods and cannot afford data loss during redirect operations. The 308 redirect represents a crucial tool for maintaining application integrity during infrastructure changes.
Frequently asked questions about 308 redirects
What is the difference between 308 and 301 redirects?
The main difference lies in how they handle request methods and data. A 301 redirect allows browsers to change the request method (typically converting POST to GET), while a 308 redirect preserves the exact original method. Additionally, 308 redirects maintain request body data throughout the process, whereas 301 redirects often discard this information.
When should I use a 308 redirect instead of 301?
Use a 308 redirect when you need to preserve the original request method and any associated data. This is particularly important for form submissions, API endpoints using POST/PUT/DELETE methods, file uploads or any scenario where changing the request method would break functionality. Choose 301 for simple page moves where method changes won't cause issues.
How do I implement a 308 redirect?
Implementation depends on your server software. For Apache, use RewriteRule with [R=308,L] flags in .htaccess files. For Nginx, use the return 308 directive in location blocks. Most programming frameworks also provide built-in methods to return 308 status codes programmatically, such as res.redirect(308, '/new-url') in Express.js.
Do search engines follow 308 redirects?
Yes, search engines treat 308 redirects the same as 301 redirects for SEO purposes. Google and other search engines will follow 308 redirects, transfer ranking signals to the new URL and update their indexes accordingly. The redirect preserves link equity and passes PageRank to the destination page.
What happens to POST data with 308 redirects?
POST data is preserved completely with 308 redirects. The browser will resubmit the exact same POST request with all original data to the new URL specified in the Location header. This makes 308 redirects ideal for handling form submissions and API calls where data loss would create problems or security concerns.
By Shannon Young
Customer Success Manager
Shannon is a seasoned professional in the customer success space. She has years of experience in a wide variety of customer-facing roles in various sectors.
Always ready to take on the next challenge, whether it be a new offensive cross stitch pattern or making her dogs sit still for another themed photo, she is prepared for anything.
