HTTP 302 Found

HTTP 302 Found indicates the resource temporarily resides at a different URL. The client should continue using the original URL for future requests. Despite being called 'Found,' it's actually a temporary redirect — the resource hasn't been found at the original URL, it's been found elsewhere temporarily. This is the most commonly used redirect in web applications, powering login redirects, A/B testing URL routing, and load balancing across origins.

Debug HTTP 302 live

Analyze real 302 behavior — headers, caching, CORS, redirects

Open Inspector →

Try it (live endpoint)

Response includes the status code, standard headers (including Content-Type), and a small diagnostic JSON body describing the request and returned status.

Simulator URL (copy in the app after load — not a normal link):

https://httpstatus.com/api/status/302

Example request:

curl -i "https://httpstatus.com/api/status/302"

Try in playground

Meaning

The URL of the requested resource has been changed temporarily.

What it guarantees

A different URI is involved to complete the intent.

What it does NOT guarantee

All clients will automatically follow the redirect.
The redirect target is safe to cache unless headers allow it.

When to use this status

Temporary redirects for maintenance, experiments, or routing changes.
Geo-based routing where the mapping may change.
Short-lived redirects where long-term caching is undesirable.

When NOT to use this status (common misuses)

Redirecting without a stable Location target.

Clients fail to follow; crawlers lose canonical signals.

Using 301/302 for non-GET methods without understanding method rewriting.

Clients can drop bodies or change methods, causing data loss and client bugs.

Redirect loops or long chains.

Crawlers waste crawl budget; clients hang; retries amplify load.

Critical headers that matter

Location

Tells clients where to go next.

Redirects fail or loop; crawlers lose canonical target.

Cache-Control

Controls whether redirects are cached.

Temporary redirects become sticky; permanent redirects never stick.

Vary

Prevents caches mixing redirect variants.

CDNs serve the wrong redirect for different hosts/headers.

Tool interpretation

Browsers

Follows Location for navigations; redirect caching can make behavior sticky. Redirect code choice affects method/body handling.

API clients

May not auto-follow; strict clients require explicit redirect handling. Incorrect redirect semantics can drop bodies or change methods.

Crawlers / SEO tools

Uses redirects for canonicalization; long chains/loops waste crawl budget and dilute signals.

Uptime monitors

Typically marks success; advanced checks may flag header anomalies or latency.

CDNs / reverse proxies

Can cache redirects; Location/Vary/Cache-Control correctness drives global consistency.

Inspector preview (read-only)

On this code, Inspector focuses on semantics, headers, and correctness warnings that commonly affect clients and caches.

Signals it will highlight

Status semantics vs method and body expectations
Header sanity (Content-Type, Cache-Control, Vary) and evidence completeness
Redirect chain length, loops, Location presence, protocol safety

Correctness warnings

No common correctness warnings are specific to this code.

Guided Lab outcome

Reproduce HTTP 302 Found using a controlled endpoint and capture the full exchange.
Practice distinguishing status semantics from transport issues (redirects, caching, proxies).
Validate redirect correctness (Location, hop count, protocol safety) and SEO impact.

Technical deep dive

302 Found (RFC 7231 Section 6.4.3) was originally called 'Moved Temporarily.' Like 301, browsers historically change POST to GET when following 302, which is technically a violation of the spec. This behavior led to the creation of 307 (which preserves the method). In practice: use 302 for temporary redirects where method preservation doesn't matter, 307 when it does. SEO: Google treats 302 as temporary — it keeps indexing the original URL and doesn't transfer PageRank. If a 302 stays in place for months, Google may eventually treat it as a 301. Caching: 302 responses are NOT cacheable by default (unlike 301).

Real-world examples

Common 302 Found scenario 1

When a server returns 302 Found, it signals specific behavior that clients and intermediaries must handle correctly. For example, in web applications, this status is commonly encountered during URL routing, content negotiation, or resource management operations.

CDN and proxy behavior with 302

CDNs and reverse proxies handle 302 Found according to their configuration. The caching and forwarding behavior depends on whether the status is cacheable by default (per RFC 7231) and the presence of Cache-Control headers. Misconfigured intermediaries can cause redirect loops or cache stale redirects.

API design with 302 Found

In RESTful API design, 302 Found serves a specific semantic purpose. API gateways may intercept and modify these responses for versioning, rate limiting, or traffic management. Understanding when to use 302 versus similar status codes is critical for correct client behavior.

Framework behavior

Express.js (Node)

Express: res.redirect(302, 'https://new-url.com'). For 301/308 permanent: ensure the Location header is correct as browsers may cache it permanently.

Django / DRF (Python)

Django: return HttpResponseRedirect('/new-url/', status=302) or use the shortcut redirect() with permanent parameter for 301/308.

Spring Boot (Java)

Spring: return ResponseEntity.status(302).header("Location", "/new-url").build(). Spring's RedirectView can be configured with specific status codes.

FastAPI (Python)

FastAPI: return RedirectResponse(url='/new-url', status_code=302). For API redirects, ensure the client follows redirects with method preservation when using 307/308.

Debugging guide

Check the Location header value — typos or relative URLs in Location can cause redirect loops or 404s
Verify caching behavior: NOT cacheable by default — check Cache-Control headers
Test with curl -v -L to follow redirects and see the full chain
Check for redirect chains — each hop adds latency; aim for direct redirects
Monitor for method change (POST→GET) which is common with 302

Code snippets

Node.js

app.get('/old-path', (req, res) => {
  res.redirect(302, '/new-path');
});

Python

from fastapi.responses import RedirectResponse

@app.get('/old-path')
async def old_path():
    return RedirectResponse('/new-path', status_code=302)

Java (Spring)

@GetMapping("/old-path")
public ResponseEntity<Void> oldPath() {
    return ResponseEntity.status(302)
        .header("Location", "/new-path")
        .build();
}

func oldPathHandler(w http.ResponseWriter, r *http.Request) {
	http.Redirect(w, r, "/new-path", 302)
}

FAQ

When should I use 302 Found vs other redirect codes?

302 Found is temporary and may change the HTTP method. Choose based on permanence (will the redirect stay?) and method preservation (does POST need to stay POST?).

How do search engines handle 302 Found?

Search engines treat this as temporary and continue indexing the original URL. They do not transfer PageRank.

Is 302 Found cacheable?

No, 302 is NOT cacheable by default. Add Cache-Control: max-age=N if you want intermediaries to cache it.

What are common pitfalls with 302 Found?

Common issues include: redirect loops (A→B→A), missing Location header, relative vs absolute URLs in Location, unexpected method change from POST to GET, and excessive redirect chains that add latency.