AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I check a redirect chain for loops, too many hops and 301 vs 302 issues without a server?

Open AnyTool’s Redirect Chain Checker, run <code>curl -sIL https://example.com</code> in a terminal (or open DevTools → Network and copy the redirect responses), and paste the output. It parses the chain into an ordered list of hops — each URL with its status code and Location — and analyses it against SEO best practice: the total hop count (1 is ideal; Google recommends ≤ 3 and follows ~10 before a redirect error), any 302 / 307 used for what looks like a permanent move (use a 301 or 308 instead), redirect chains you should collapse from A→B→C to A→C, redirect loops that break the page, http→https upgrades (good) and https→http downgrades (bad), the final status (200 good, 4xx/5xx bad, still-redirecting), and www / trailing-slash canonicalization. You get a visual hop-by-hop chain, a findings panel with a concrete fix for every issue, and the parsed hop table. It runs 100% in your browser, so your URLs are never uploaded. A browser can’t trace another site’s redirects (CORS, and fetch() auto-follows without exposing the hops) and there’s no server proxy — so paste the curl output, and verify live behaviour with curl or a server-side checker.

  • Paste curl -IL output (or DevTools) → an ordered chain of hops with status codes
  • Flags too many hops, redirect loops, and chains to collapse (A→B→C ⇒ A→C)
  • 301 vs 302/307/308: warns when a temporary code is used for a permanent move
  • Checks http→https (good) / https→http (bad) and the final status (200 vs 4xx/5xx)
  • 100% client-side — your URLs never uploaded; a browser can’t trace redirects, so paste curl

What is

Redirect chain (and redirect loop)

A redirect chain is a sequence in which one URL redirects to another that redirects again before reaching the final page — for example A → B → C instead of A → C directly. Each hop adds latency, spends crawl budget and slightly dilutes the ranking signals passed along, so the goal is a single hop straight to the destination. A redirect loop is a special, broken case where a URL eventually redirects back to one already visited (A → B → A), so the browser and Googlebot hit “too many redirects” and the page never loads or gets indexed. Search engines follow a limited number of hops (Googlebot up to about 10, but usually only ~5 per crawl), so long chains risk the final page never being reached.

SEO & Web

Related terms

301 redirect302 redirect307 redirect308 redirectRedirect loopCrawl budgetHTTP status codeCanonicalization

Frequently Asked Questions

301 and 308 are permanent — Google passes ranking signals to the new URL. 302, 307 and 303 are temporary — Google keeps the old URL indexed. Use 301/308 for real moves.

The 3xx redirect codes split on two axes. Permanent vs temporary: 301 (Moved Permanently) and 308 (Permanent Redirect) tell Google the move is final, so it consolidates ranking signals to the destination and eventually drops the old URL; 302 (Found), 307 (Temporary Redirect) and 303 (See Other) say the change is temporary, so Google keeps the OLD URL in the index and does not pass signals. Method preservation: 307 and 308 are the strict modern equivalents that keep the HTTP method (important for POST), while 301/302 may switch to GET and 303 always forces GET. For a permanent move use 301 (or 308 for non-GET); reserve 302/307 for genuine temporary detours like A/B tests or maintenance. Note that Google’s John Mueller has said 301 and 308 are equivalent for SEO — there is no ranking penalty for choosing one over the other.

Each hop in a chain adds latency, wastes crawl budget and slightly dilutes link signals; a loop breaks the page entirely with “too many redirects”. Collapse chains to one hop.

A redirect chain (A → B → C) multiplies problems: every extra hop adds network latency that hurts Core Web Vitals, counts as an additional request that drains crawl budget so fewer of your pages get crawled, and slightly dilutes the link equity passed to the destination. Googlebot follows up to about 10 hops before flagging a redirect error and excluding the page, and usually only follows around five per crawl, so a long chain risks the final page never being indexed. A redirect loop is worse — a URL redirects back to one already in the path, so the browser shows “ERR_TOO_MANY_REDIRECTS” and the page never loads. The fix in both cases is to point every source URL directly at the final destination in a single hop.

No — a browser can’t. Cross-origin requests are blocked by CORS and fetch() auto-follows redirects without exposing the hops. Run curl -sIL and paste the output.

A browser genuinely cannot trace another site’s redirects for you. Cross-origin requests are blocked by the Same-Origin Policy / CORS, and even for a same-origin URL a fetch() automatically follows every redirect and never exposes the intermediate 3xx responses (status codes and Location headers) to JavaScript — with redirect:"manual" you only get an opaque response with status 0. We also deliberately use no server proxy, which is what keeps your URLs private. So the reliable path is to run curl -sIL https://your-url in a terminal (curl prints every hop’s status and Location) or open DevTools → Network, and paste that chain here. The tool then analyses exactly what you pasted, entirely in your browser.

One hop is ideal. Google recommends keeping chains to 3 hops or fewer and follows about 10. The final URL should return 200 — never redirect to a 404 or 500.

The ideal redirect is a single hop straight to the destination. Google recommends keeping any chain to about three hops or fewer, follows up to roughly ten before flagging a redirect error, and typically only follows around five per crawl — so more than a couple of hops is worth collapsing. Just as important is where the chain ends: the final URL should return a 200 OK. A redirect that ends on a 4xx (like a 404 or 410) or a 5xx server error wastes the redirect entirely, loses any accumulated link equity and creates a broken experience — redirecting to a missing page is worse than letting the old URL simply 404. The checker flags the final status and warns if the chain still ends on a redirect.

Detailed Explanation

How It Works

What the Redirect Chain Checker Analyzes

The Redirect Chain Checker takes a redirect chain the user PASTES — from running curl -sIL https://example.com in a terminal, or from DevTools → Network → the redirect responses — and analyses it against SEO best practice, entirely in the browser. A small pure engine, redirectEngine.ts, does the work with plain string parsing and no dependency. parseChain(raw) accepts several input shapes: curl -IL / curl -v output (repeated “HTTP/x 301” status lines each followed by a “Location:” header, with curl’s < / > / * markers stripped), a plain list of “URL 301” / “301 URL” lines, and “from → to” / “from => to” arrow lines — and builds one ordered CHAIN of hops, each with its URL, numeric status, reason phrase, resolved Location and a classified kind (permanent 301/308, temporary 302/307/303, other-3xx, success, client-error, server-error, meta-refresh). analyzeChain(hops) then produces a findings list with a severity (good / warn / bad / info) and a concrete fix for each issue, plus a summary: total redirect hops, whether it is a chain or a loop, the final status and the start/end URLs. The page renders a VISUAL hop-by-hop chain with a status badge on every step, a findings panel, and the parsed hop table.

  • Paste curl -IL output, a “URL 301” list, or “from → to” arrows — parseChain handles all three shapes
  • Builds an ordered chain of hops: URL + status code + Location + classified redirect kind
  • analyzeChain flags hop count, 301-vs-302, chains, loops, http↔https, final status, canonicalization
  • Every finding carries a concrete fix (collapse A→B→C to A→C, switch 302→301, upgrade to HTTPS)
  • All parsing and analysis is pure client-side JavaScript — no server call, no CDN, no upload, no proxy
Methodology

The SEO Checks It Runs on a Redirect Chain

Every check maps to a documented redirect best practice. HOP COUNT: one hop is ideal; more than one is a chain that should be collapsed (Google recommends keeping chains to about three hops or fewer, follows up to roughly ten before flagging a redirect error, and usually only follows around five per crawl), and each hop adds latency, spends crawl budget and slightly dilutes link signals. LOOP DETECTION: it normalises each URL and detects any that repeats, reporting the cycle — a loop causes “too many redirects” so the page never loads or indexes. 301 vs 302/307/308: a temporary code (302 Found, 307 Temporary Redirect, 303 See Other) in the chain is warned about because Google keeps the OLD URL indexed and does not consolidate ranking signals — for a permanent move it recommends 301 (or 308 when the HTTP method must be preserved for non-GET), noting that 301 and 308 are equivalent for SEO. PROTOCOL: an http→https upgrade is credited as correct while an https→http downgrade is flagged as an insecure downgrade, and an http final URL is warned about. FINAL STATUS: a 200 is good, a chain still ending on a 3xx is warned, and a redirect to a 4xx/5xx error is flagged as a bad redirect that wastes the redirect and any link equity. It also notes www/non-www and trailing-slash canonicalization hops and meta-refresh / JavaScript redirects (discouraged in favour of a server-side HTTP redirect).

  • Hop count: 1 ideal; warns > 1 (Google recommends ≤ 3, follows ~10 before a redirect error)
  • Loop detection via normalised-URL repeat — reports the exact cycle
  • 301/308 (permanent, passes signals) vs 302/307/303 (temporary, keeps old URL indexed)
  • http→https upgrade credited; https→http downgrade and http final URL flagged
  • Final status: 200 good, still-3xx warned, redirect-to-4xx/5xx flagged as a broken redirect
Limitations

A Browser Can’t Trace Another Site’s Redirects — Paste the Chain

The tool is explicit about one hard limitation of any client-side redirect checker: a browser CANNOT trace another site’s redirect chain for you. Cross-origin requests are blocked by the Same-Origin Policy / CORS, so a page’s JavaScript cannot fetch an arbitrary URL; and even for a same-origin or CORS-enabled URL, the browser’s fetch() AUTOMATICALLY follows every redirect and never exposes the intermediate 3xx responses (their status codes and Location headers) to JavaScript — using redirect:"manual" only yields an opaque response with status 0 and a hidden Location, which the tool demonstrates with its optional “try to fetch” button. There is deliberately NO server proxy, because that is what keeps the user’s URLs private and the tool 100% client-side. So the reliable path is to run curl -sIL https://your-url (curl prints every hop’s status line and Location) or read DevTools → Network, and paste that chain. Because the tool analyses what you paste rather than the live site, and a real chain can vary with cookies, geolocation, user-agent or caching, it advises verifying live behaviour with curl or a server-side redirect checker. It is best-practice GUIDANCE on the pasted chain, not a live crawl.

  • A browser can’t trace another site’s redirects: CORS blocks cross-origin, fetch() hides the hops
  • redirect:"manual" returns an opaque status-0 response — no status code or Location for JS
  • No server proxy by design, so your URLs stay private — you paste curl -IL / DevTools output
  • Analyses the pasted chain, not the live site; a real chain can vary by cookie/geo/UA/cache
  • Verify live behaviour with curl -sIL or a server-side redirect checker
Privacy & Security

Why Checking Redirects In-Browser Is a Privacy Win

Online redirect checkers fetch your URL server-side, which exposes which URLs you are auditing (and any tokens or campaign parameters in them) to a third-party service. The Redirect Chain Checker instead runs entirely on the user’s device: the chain you paste is parsed and analysed with plain JavaScript, nothing is fetched, uploaded, logged or stored, and no site is contacted (there is deliberately no server proxy). That makes it safe to analyse STAGING, INTERNAL or CLIENT URLs — including ones with private query strings — without sending them anywhere. The tool works offline once cached as a PWA, and closing the tab discards everything entered. It adds no new dependency: all the parsing (parseChain) and the SEO analysis (analyzeChain) live in the small, reusable, well-typed engine redirectEngine.ts, and it uses only custom in-house SVG icons and the shared ad and SEO components — the same golden pattern as its SEO & Web siblings.

  • The redirect chain is parsed locally and never uploaded — no server, no CDN, no crawl, no proxy
  • Safe for staging / internal / client URLs with private query strings, unlike online checkers
  • Works offline once cached; closing the tab discards your data
  • No new dependency — all logic lives in the pure engine redirectEngine.ts
  • Dark mode and mobile support with a sticky Analyze / Copy bar
Redirect-chain checking: in-browser (AnyTool) vs online checkers
CapabilityAnyToolTypical online checkers
ProcessingRuns entirely in your browserFetches your URL server-side
Your URLsNever uploaded, works offlineSent to a third-party service
Staging / private URLsSafe — nothing leaves the deviceExposed, including query strings
InputPaste curl -IL / DevTools chainA URL the tool crawls for you
Live crawlNo (a browser can’t trace redirects)Yes (its main feature)
AnalysisHops, loops, 301 vs 302, http→https, final statusVaries
FixesA concrete fix per findingOften just a status list
HonestyClear it analyses the pasted chain — verify with curlImplies it is authoritative
Cost / signupFree, no signupOften gated or ad-heavy

AnyTool analyses a redirect chain you paste (from curl -IL or DevTools) locally and uploads nothing, which is safe for staging or private URLs. A browser cannot trace another site’s redirects — CORS blocks cross-origin requests and fetch() auto-follows without exposing the hops — and there is no server proxy, so this is not a live crawler; verify live behaviour with curl or a server-side checker. Comparison as of July 2026.