What Is a 307 Status Code?

The 307 Temporary Redirect is an HTTP response status code defined in RFC7231 Section 6.4.7. It tells the client that the requested resource temporarily resides at a different URI and that the client should access the new URI without changing the original HTTP method used in the request.

In simpler terms, the server says:
“I’ve temporarily moved this resource to a new address — follow the Location I give you, but make sure you use the same method (like POST, PUT, or DELETE) when you go there.”
This preservation of the HTTP method is what distinguishes 307 from other commonly known temporary redirects, particularly the 302 Found status.

Key Characteristics of 307 Temporary Redirect

✅ Temporary nature
The redirect is meant to be short-term. The client should continue using the original URI for future requests unless instructed otherwise by a subsequent redirect.

✅ HTTP method preservation
Unlike a 302 redirect, where many clients (especially older browsers) might change a POST into a GET during redirection, a 307 requires that the client resend the request using the exact same method and body as the original. For example:

A POST remains a POST.
A PUT remains a PUT.
A DELETE remains a DELETE.

✅ Location header provided
The server must include a Location header in the response, specifying the temporary URI where the client should send its request.

✅ Automatic or manual follow
Modern browsers and HTTP clients usually follow the redirect automatically, but technically, the client has the option to present the redirect to the user (for example, showing a clickable link).

Related Resources

What is a 101 Status Code?
What is a 102 Status Code?
What is a 200 Status Code?
What is a 201 Status Code?
What is a 202 Status Code?
What is a 208 Status Code?
See All Status Code

SEO Services

Other Services

Insights

Blogs

Why Was 307 Introduced?

The 307 status code was designed to fix the ambiguity of the 302 status code.

While 302 indicates a temporary redirect, many clients incorrectly treated it as a GET redirect, even if the original method was POST.
307 was added to clearly specify that the request method must not change — ensuring consistency across clients and improving predictability for developers.

This makes 307 particularly important in web applications, REST APIs, and services where maintaining the integrity of POST, PUT, or DELETE operations during redirects is critical.

Practical Example

Imagine a user submits a form (POST) to:

POST /submit-payment

The server needs to temporarily redirect them to:

/temporary-gateway

Instead of downgrading the request to a GET (which would happen under a 302 in many clients), the server issues:

HTTP/1.1 307 Temporary Redirect  
Location: /temporary-gateway

The client then resends the POST request to /temporary-gateway, ensuring the payment submission process remains intact.

The 307 Temporary Redirect is a precise, method-preserving, temporary redirect designed for situations where:

The resource is only temporarily available at a different URI.
The integrity of the HTTP method must be preserved.
Clients and servers need predictable, standards-compliant redirect behavior.

How Does a 307 Redirect Work?

A 307 Temporary Redirect operates through a precise sequence of steps between the client (browser, API consumer, or tool) and the server, ensuring that both the temporary nature of the redirect and the integrity of the original HTTP method (like POST, PUT, DELETE) are preserved during the redirection process.

Let’s walk through the full technical flow.

Step 1: Client Sends an Initial Request

The client starts by making an HTTP request to a resource. This can be:

A GET request (typical page load).
A POST request (form submission or API call).
A PUT or DELETE request (in REST APIs).

Example:

POST /submit-order HTTP/1.1  
Host: example.com  
Content-Type: application/json  
Content-Length: 150

Step 2: Server Responds with 307 Temporary Redirect

The server decides that the resource is temporarily available at another location.
Instead of fulfilling the request at the original URI, it responds:

HTTP/1.1 307 Temporary Redirect  
Location: https://temporary.example.com/process-order  
Cache-Control: no-cache

Important details:

307 status line → Indicates a temporary redirect.
Location header → Provides the exact URI where the client should go next.
No change in method → Signals to the client that the HTTP method and body must remain unchanged.

Step 3: Client Follows the Redirect (Without Changing Method)

Unlike with a 302, where older or less compliant clients might automatically downgrade the request to a GET, the client handling a 307 must:

Resend the same HTTP method.
Preserve the original request body (if any).

Example follow-up request:

POST /process-order HTTP/1.1  
Host: temporary.example.com  
Content-Type: application/json  
Content-Length: 150

This behavior is essential for operations like payment processing, file uploads, or sensitive form submissions, where changing the method could break the logic or cause data loss.

Step 4: Client Continues Using Original URI for Future Requests

Since 307 is a temporary redirect, the client understands that:

It should only redirect this request.
Future requests should still target the original URI unless told otherwise (for example, with another redirect later).

Why Is This Flow Important?

This method-preserving flow solves key problems:

Predictability: Developers can rely on the redirect working consistently across compliant clients.
Integrity: POST, PUT, and DELETE actions are preserved, avoiding unintended side effects.
Temporary nature: Allows dynamic rerouting without permanently changing bookmarks, links, or client configurations.

A 307 redirect works by:

Receiving a client request.
Issuing a redirect response with the Location header and a guarantee that the client will preserve the original method.
Ensuring that only the current request is affected — future requests still point to the original URI.

307 Code References Across Frameworks

When implementing a 307 Temporary Redirect in real-world applications, developers don’t usually hardcode the number 307 directly into their code. Instead, they rely on constants, helper functions, or predefined symbols provided by their framework or programming language.

Using these built-in references improves:

Code readability
Maintainability
Reduced risk of typos or mistakes

Let’s break down how the 307 status code is represented across popular development environments.

Common 307 References by Language or Framework

Environment / Language	Code Reference
Ruby on Rails	`:temporary_redirect`
Go (Golang)	`http.StatusTemporaryRedirect`
Symfony (PHP)	`Response::HTTP_TEMPORARY_REDIRECT`
Python 2	`httplib.TEMPORARY_REDIRECT`
Python 3+	`http.client.TEMPORARY_REDIRECT`
Python 3.5+	`http.HTTPStatus.TEMPORARY_REDIRECT`
.NET (C#)	`HttpStatusCode.TemporaryRedirect`
Rust	`http::StatusCode::TEMPORARY_REDIRECT`
Java	`java.net.HttpURLConnection.HTTP_TEMP_REDIRECT`
Apache HttpComponents Core	`org.apache.hc.core5.http.HttpStatus.SC_TEMPORARY_REDIRECT`
Angular (TypeScript)	`@angular/common/http/HttpStatusCode.TemporaryRedirect`

Example Code Snippets

Python (Flask)

from flask import redirect

@app.route('/old')
def old_route():
    return redirect('/new', code=307)

Go (Golang)

http.Redirect(w, r, "/new", http.StatusTemporaryRedirect)

Symfony (PHP)

use Symfony\Component\HttpFoundation\RedirectResponse;

$response = new RedirectResponse('/new', Response::HTTP_TEMPORARY_REDIRECT);
$response->send();

Node.js (Express)

app.post('/submit', (req, res) => {
    res.redirect(307, '/temporary-handler');
});

Why Use These Constants?

✅ Clarity: You immediately know from the constant name (TemporaryRedirect) what the code is doing, rather than guessing what 307 means.

✅ Error Prevention: You avoid introducing numeric typos like writing 370 or 317.

✅ Framework Features: Many frameworks offer additional behaviors (like logging or special redirect handling) when you use their provided redirect helpers or constants.

Across modern programming languages and frameworks, the 307 Temporary Redirect is supported through well-named constants and helpers, making it easy to implement reliable, standards-compliant redirects. Using these references not only improves your code quality but also ensures you’re following best practices for HTTP development.

Best Practices for Using 307 Redirects

The 307 Temporary Redirect is a precise tool meant for situations where you need to temporarily move a resource but preserve the exact HTTP method (such as POST, PUT, or DELETE) during the redirect. To implement it effectively and avoid mistakes that can harm user experience, system behavior, or SEO, it’s important to follow established best practices.

Let’s explore the key guidelines.

1. Use 307 Only for Temporary Redirects

The 307 status is explicitly designed for situations where:

The resource is temporarily available at a different URI.
You fully expect the resource to return to its original location in the future.

If you’re planning to permanently move a resource, you should use:

301 Moved Permanently (if you don’t need to preserve the HTTP method), or
308 Permanent Redirect (if you do need to preserve the HTTP method).

Misusing 307 for permanent changes can lead to:

Confusion for clients.
Improper cache or bookmark updates.
Negative SEO impacts due to duplicate indexing.

2. Ensure the Original Resource Remains Accessible

While the redirect is in place, make sure that:

The original URI still resolves (unless deliberately taken offline).
Clients can continue using the original URI for future requests, as they’re instructed to treat the redirect as temporary.

Taking down or permanently blocking the original URI while issuing a 307 can lead to:

Broken links.
Failed automated requests or API calls.
Increased error rates.

3. Maintain the Correct HTTP Method

One of the biggest reasons to choose 307 over 302 is its guarantee that the original HTTP method will be preserved.

You must:

Expect the client to resend POST as POST, PUT as PUT, DELETE as DELETE, etc., when following the redirect.
Ensure that the destination endpoint (Location) is prepared to handle the same method and request body.

For example, if a form submission (POST) is temporarily rerouted to another server, the receiving server must handle the POST, not just a basic GET.

4. Confirm Redirect Destination URLs

Before deploying, always:

Test the redirect paths using tools like curl, Postman, or an online redirect checker.
Make sure the Location header points to a valid, reachable endpoint.
Check that the destination server properly handles the preserved method and any request payload.

Bad or broken redirect destinations can cause:

User-facing errors.
API failures.
Search engine crawler confusion.

Common Mistakes with 307 Redirects

While the 307 Temporary Redirect is a precise and valuable tool for managing temporary redirects while preserving the HTTP method, it’s easy for developers or system administrators to misuse or misinterpret it. These mistakes can lead to broken functionality, poor user experience, or even SEO penalties.

Let’s break down the most common pitfalls so you can avoid them.

1. Misinterpreting 307 as a Permanent Redirect

One of the most frequent mistakes is assuming that 307 is a permanent redirect — it is not.

307 should only be used when:

The redirection is short-term or transitional.
The original URI is expected to remain the primary long-term address.

If you treat a 307 like a permanent change, you risk:

Clients continually hitting the original URI even when they should update to the new one.
Inefficient use of network or system resources.
Missed SEO opportunities for consolidating ranking signals (which only 301 or 308 provide).

2. Using 307 for Permanent Moves

Related to the first point, another common error is applying 307 when a resource has permanently moved.

For permanent moves, the correct status codes are:

301 Moved Permanently → if you don’t care about method preservation.
308 Permanent Redirect → if you need to preserve the HTTP method.

Using 307 in permanent situations can:

Confuse clients and crawlers.
Create duplicate content in search engines.
Fail to pass SEO link equity to the destination URL.

3. Assuming It’s Just Like a 302

Many developers treat 307 as just a “better 302” — but they miss the crucial technical difference.

302 Found allows clients to change the HTTP method (many will switch POST to GET).
307 Temporary Redirect requires that the method stays the same.

If you set up 307 without ensuring the target system is ready to handle the original method (especially POST, PUT, or DELETE), you can cause:

Method mismatch errors.
Failed form submissions or API requests.
Broken application flows.

How to Troubleshoot a 307 Status Code

When you encounter an unexpected 307 Temporary Redirect, whether on your own website, in an application, or while working with third-party services, it’s important to diagnose the cause carefully to avoid functionality issues or negative impacts on user experience.

Here’s a step-by-step guide to troubleshoot and resolve 307-related problems.

Step 1: Check Your Server Configuration

Start by reviewing:

Server-side redirect rules (like .htaccess for Apache, nginx.conf for NGINX, or Express.js routes).
Application-level redirects set in frameworks (like Flask, Django, Rails).

Questions to ask:

Are you intentionally using a 307, or is it being generated automatically?
Is the redirection targeting the correct temporary URI?

Misconfigured or unintended redirect rules are a leading cause of unnecessary or incorrect 307s.

Step 2: Verify the HTTP Method

Since 307 preserves the original HTTP method, check:

Is the original method (e.g., POST, PUT) appropriate for the redirected endpoint?
Is the destination server configured to handle the same method correctly?

For example, redirecting a POST to a location that only handles GET requests will fail.

Step 3: Test the Redirect Flow

Use tools like:

curl -v or curl -i to inspect headers and redirection chains.
Browser developer tools (Network tab) to see real-time redirects.
Postman or HTTP client libraries to test API requests and follow the redirect manually.

Look for:

The Location header → is it pointing where you expect?
Any intermediate or chained redirects → are you creating loops or unnecessary hops?

Step 4: Confirm Resource Availability

Make sure:

The original resource is still accessible (if required).
The temporary target is online, properly configured, and returns the expected responses.

Sometimes a 307 hides a backend issue where the final target returns an error or fails to process the request.

Step 5: Monitor and Validate

After applying fixes, validate:

Run automated tests to check that the 307 behavior is working as intended.
Use monitoring tools (like Google Search Console, Pingdom, or uptime monitors) to catch any new or recurring redirect problems.

For APIs, ensure that any clients or integrations are properly handling 307s, especially if they were written assuming 302 behavior.

FAQs About 307

Why Is a 307 HTTP Status Code Important?

The 307 status code ensures that:

Temporary redirects are handled without changing the HTTP method (POST stays POST, PUT stays PUT).
Applications and APIs maintain data integrity during sensitive operations like form submissions, payment processing, or file uploads.
Clients and crawlers know the redirection is temporary, so they continue using the original URI for future requests.

This helps maintain a smooth user experience, reduce data loss, and ensure proper behavior across tools and platforms.

What’s the Difference Between a 307 Status Code and a 302 Status Code?

While both indicate temporary redirects, they handle request methods differently:

302 Found: Originally ambiguous — many clients downgrade POST to GET during the redirect.
307 Temporary Redirect: Explicitly requires clients to preserve the original method and request body.

If you need guaranteed method preservation, 307 is the correct choice.

What’s the Difference Between a 307 Status Code and a 308 Status Code?

307 Temporary Redirect: Indicates a temporary move; future requests should still target the original URI.
308 Permanent Redirect: Indicates a permanent move while also preserving the HTTP method, signaling clients to update bookmarks, caches, and stored references.

Use 308 for permanent, method-preserving redirects, and 307 for short-term, temporary situations.

Does a 307 Status Code Affect SEO?

Typically, no — because search engines like Google treat 307 as a temporary redirect and continue indexing the original URL. However:

Misusing 307 for permanent moves can create SEO problems like duplicate content.
Proper use ensures that bots understand the move is short-term and don’t shift ranking signals to the temporary destination.

When Should I Choose 307 Over 301 or 302?

Use 307 when:

You need a temporary redirect.
You must preserve the HTTP method and body.

For example, if you’re rerouting a POST request temporarily (like during maintenance or load balancing), 307 ensures the redirected request is still a POST, unlike 302, which may downgrade it to a GET.

307 vs. Other Redirect Codes

To fully understand when to use the 307 Temporary Redirect, it’s essential to compare it directly to other common HTTP redirect status codes — especially 301, 302, and 308. These codes differ in whether they indicate temporary or permanent changes and whether they preserve the HTTP method (like POST or PUT). Let’s break it down.

1️⃣ 301 Moved Permanently

Purpose: Indicates the resource has permanently moved to a new URL.
Behavior: Clients should update bookmarks and future requests to the new URI.
HTTP Method Handling: Allows clients to change the method (POST → GET, for example).

Key Difference from 307: 301 is for permanent moves and may allow method changes, while 307 is for temporary moves and strictly preserves the original method.

2️⃣ 302 Found

Purpose: Signals a temporary move to a new location.
Behavior: In older standards, it was ambiguous whether the client should change the method; many implementations switched POST requests to GET.
HTTP Method Handling: Not guaranteed to preserve method (this ambiguity led to the creation of 307).

Key Difference from 307: 302 is less strict about method preservation, making 307 the safer choice when you need to maintain method integrity.

3️⃣ 308 Permanent Redirect

Purpose: The resource has permanently moved, and the client must preserve the original HTTP method.
Behavior: Functions like 301 but guarantees method preservation.
HTTP Method Handling: POST stays POST; PUT stays PUT.

Key Difference from 307: 308 is the permanent counterpart to 307 — both preserve the method, but 308 is for permanent moves.

Code	Name	Temporary/Permanent	Preserves HTTP Method?
301	Moved Permanently	Permanent	No (method may change)
302	Found	Temporary	No (method may change)
307	Temporary Redirect	Temporary	Yes (method must stay)
308	Permanent Redirect	Permanent	Yes (method must stay)

When to Choose 307

✅ When you need to temporarily redirect a resource. ✅ When the client must resend the request using the same HTTP method. ✅ When you want predictable, standards-compliant behavior across modern browsers and APIs.

Additional resources

Return to Glossary

Return to SEO Firm Dubai