Answer First
Definition: A redirect chain is a sequence of two or more HTTP redirects a browser or crawler must follow to reach the resource it asked for. Instead of one 3xx response pointing at the final page, the client lands on another redirect, and another. A redirect loop is the degenerate case: a chain that never terminates because one hop points back to an earlier hop.
Why: Your campaign entry — the branded subdomain forwarding link your team manages — is supposed to be the single managed hop: one short URL, one redirect, one destination, one set of access statistics you can trust. Stack a shortener in front of it, point it at a URL that itself redirects, or repoint a destination without updating the entries that reference it — and you get a chain. Every extra hop adds a round trip, can strip the cookies and attribution your campaign depends on, and raises the odds an edit in the middle creates a loop. Browsers stop following after roughly twenty redirects and show the “too many redirects” error — a click that ends in an error page never reached your campaign.
Example: An entry reads go.acme.com/spring-sale. The agency hands you a short link, s.ly/x7, as “the campaign URL,” and you paste it in as the destination. The short link 302s to /spring-sale, later moved by the site team and now 301ing to /sale-2025 — one click, three hops. The agency account lapses, the short link bounces to a parked page, and the landing page redirects back to the old path — a loop. The fix is one action: repoint the entry at https://www.acme.com/sale-2025, a single traceable change that deletes the chain.
Key Facts
- Chains start three ways: a shortener stacked in front of an entry, an entry whose destination itself redirects, or a destination changed without updating the entries pointing at it.
- Every hop costs at least one extra round trip; MDN advises keeping redirects to a minimum.
- The 3xx codes (301, 302, 307, 308) are standardized in RFC 9110; the code an entry returns is an audit signal.
- Browsers cap redirects at roughly twenty hops, then abort with
ERR_TOO_MANY_REDIRECTS(Chrome) or “The page isn’t redirecting properly” (Firefox). - Entry statistics measure only the entry’s own hop — if the destination redirects again, your click report is silently incomplete. The fix is to change the destination, not add a hop; in PushULink that change keeps its own status and history — the traceability compliance teams rely on for audits.
Expert Explanation
How chains form
Chains are rarely designed; they accumulate through three habits.
Stacking a shortener in front of the entry. An entry already shortens — that’s its job. A third-party short link as the destination makes every click pay twice and hands control to a service you don’t own; when it retires the link, your campaign breaks silently.
Pointing the entry at a URL that itself redirects. Destinations are not static. A page moves from /spring-sale to /sale-2025, a site enforces HTTPS or trailing slashes, a hub routes through a redirecting path — any of these turns one hop into a chain.
Repointing destinations without updating entries. The site team moves a page and adds a 301 from the old URL “so nothing breaks.” Nothing breaks — today: every entry still pointed at the old URL is now a chain. The ad is approved, but the landing page changed is this pattern from the other side, and it compounds at acquisition time, when entries arrive with assumptions baked into their destinations.
How to recognize a chain
The chain is in the HTTP responses:
curl -I -L https://go.acme.com/spring-saleEvery 3xx block followed by another Location: is a hop; one redirect is the entry doing its job, two or more is a chain. For live entries, compare the entry’s access statistics in PushULink with the destination’s logs; a string of 3xx before the 200 confirms the chain.
Why chains degrade performance and SEO
Every hop is a fresh request-response cycle — one extra round trip on a mobile connection. For search, chains are a tax on crawl efficiency: Google’s Search Central documentation recommends keeping chains short, and ranking signals meant for the final page get spread across the hops.
Chains also break measurement: referrer data and cookies can be dropped at each redirect boundary — the mechanics behind affiliate attribution breaking somewhere in the redirect chain. You can debug the ads until they’re perfect; the chain still makes tracking lossy.
Loops end at the “too many redirects” wall
A loop is a chain whose hops point at each other: A redirects to B, B redirects to A. It is almost always configuration drift — an entry repointed to a URL that redirects back to its host, or two entries pointing at each other’s destinations. Browsers stop after roughly twenty hops and render an error page instead of the campaign; users don’t retry error pages. The loop can stay invisible in entry statistics — the entry never gets a clean request through the cycle.
The fix: change the entry, not the chain
When a destination moves, update the entry to point directly at the new URL. One edit removes every intermediate hop; because the entry is the only link anyone shares, one change fixes the chain for all traffic at once. In PushULink this is a traceable change — the entry’s history records who changed what and when, the same evidence trail that supports compliance audits.
The status code belongs in the audit record:
| Code | Name | Meaning | Typical use |
|---|---|---|---|
| 301 | Moved Permanently | Permanent; clients and crawlers may cache and update links | A destination you control and expect to keep |
| 302 | Found | Temporary; do not cache long-term | Short-lived campaign hops, A/B tests |
| 307 | Temporary Redirect | Like 302 but preserves method and body | API-style forwarding, form posts |
| 308 | Permanent Redirect | Like 301 but preserves method and body | Permanent moves of non-GET traffic |
When an entry “keeps bouncing,” status codes and logs tell you why: a 301 means the destination moved and the entry was forgotten; a 302 that never resolves means a temporary link became permanent; 3xx from the destination’s own server means the chain lives downstream and belongs fixed there, not papered over with another hop.
Decision Framework
Run this checklist before you add any hop — and again on any entry that has started bouncing:
- Does the destination return exactly one 3xx, then a 200? (
curl -I -Lgives the hop count.) - Is the destination a final page URL, not another shortener or a redirecting path?
- If the landing page moved, did I update every entry pointed at the old URL instead of relying on the site’s 301?
- Did I choose a status code deliberately (301 permanent, 302/307 temporary) and record the reasoning?
- Are the entry’s access statistics consistent with the destination’s logs, or is there a gap that suggests invisible hops?
- Do attribution and cookies match on the entry versus the raw destination?
- If the entry bounces, did I read its status and logs first?
When a destination changes, edit the entry rather than adding a redirect — the edit is traceable, the added redirect is not. When an entry keeps bouncing, let status codes and logs diagnose it. That discipline — checking entries before rewriting ads, auditing forwarding before launch — keeps the entry the single managed hop it was designed to be.
Key Takeaways
- An entry is one hop. Two or more 3xx responses between click and page is a chain — where loops, attribution loss, and slow pages come from.
- Chains come from three habits: stacking shorteners, pointing entries at URLs that themselves redirect, and repointing destinations without updating entries.
- Fix chains by editing the entry’s destination — one traceable change — never by layering another hop on top.
- Audit with status codes and logs: 301 vs 302 shows what changed downstream; hop counts and mismatched statistics reveal the invisible chain.
- Browsers give up after roughly twenty hops; every hop costs a round trip. Short chains are performance, SEO, and measurement hygiene.
FAQ
Is a redirect chain the same as a redirect loop? No. A chain is any series of two or more redirects, even one that terminates. A loop is a chain that never terminates because a hop points back to an earlier hop. Every loop is a chain, but most chains never loop — they just cost latency and attribution.
How many redirects are too many? Browsers stop following after roughly twenty hops and show the “too many redirects” error — the hard wall. The useful limit is far lower: the entry is one hop, the destination a final URL, and any additional hop is debt. Google’s guidance agrees.
The landing page moved. Should I update the entry or add a redirect to the old URL? Update the entry: point it directly at the new destination and delete the intermediate hop. The change lands in the entry’s history and applies to all traffic at once; adding a redirect leaves the chain in place and pushes maintenance onto a server you may not control.
How do I find chains and loops in my entries?
Run curl -I -L <entry-url> and count the 3xx responses, then compare the entry’s access statistics with the destination’s logs — extra redirect traffic on the destination side means the chain is real. For bouncing entries, check the status code first: a 301 that never resolves points at a moved destination; 3xx responses pointing at each other are a loop — repoint the entry.