A link check can report success and still miss the thing you wanted to test.
Suppose your acceptance rule is: “This internal link must reach its destination without an HTTP redirect.” Checking only (await fetch(url)).status === 200 does not express that rule. With default redirect handling, the response can describe the final destination rather than the first response.
This example isolates that distinction with a disposable local server. It is a synthetic regression test, not a crawl of a client website or evidence of an SEO improvement.
AI disclosure: This article and its code were generated by an AI assistant. The executable example was run locally on Node.js v24.22.3. The test output below comes from that run; the routes and page content are invented fixtures.
Two assertions, two different questions
“Does the destination eventually return 200?” and “Does this exact URL return 200 directly?” are different checks.
| Fixture | First response | Result with normal following |
|---|---|---|
/direct | 200 | 200 |
/old | 301 to /direct?source=example | 200 |
/chain | 302 to /old | 200 after two hops |
/loop | 307 to itself | Cannot finish successfully |
/missing | 404 | 404 |
The table describes the server defined below. The script deliberately follows only /old; its other assertions inspect the first hop. It does not run a redirect loop to exhaustion.
A successful eventual response is useful evidence, but it is not evidence of a redirect-free link. In this test, redirect: 'manual' makes the first response observable. The expected status is exactly 200, not just response.ok, which also includes other 2xx statuses.
A copy-and-run regression test
Save the following as redirect-check.mjs and run node redirect-check.mjs. It uses Node's built-in HTTP server, assertions and fetch. No package installation, account, credentials or public target is needed. The server binds only to loopback and chooses a temporary port.
import assert from 'node:assert/strict'; import { createServer } from 'node:http'; // Local, synthetic fixtures only. Nothing is fetched from the public internet. const server = createServer((req, res) => { const url = new URL(req.url, 'http://fixture.invalid'); if (url.pathname === '/direct') { res.writeHead(200, { 'Content-Type': 'text/plain' }); res.end('Example page'); } else if (url.pathname === '/old') { res.writeHead(301, { Location: '/direct?source=example' }); res.end(); } else if (url.pathname === '/chain') { res.writeHead(302, { Location: '/old' }); res.end(); } else if (url.pathname === '/loop') { res.writeHead(307, { Location: '/loop' }); res.end(); } else { res.writeHead(404); res.end('Not found'); } }); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); const origin = `http://127.0.0.1:${server.address().port}`; async function firstHop(href) { const requested = new URL(href, origin); // This demo accepts only its own fixture origin, not arbitrary URLs. if (requested.origin !== origin || requested.username || requested.password) { throw new Error('Outside the local fixture origin'); } const response = await fetch(requested, { method: 'GET', redirect: 'manual', signal: AbortSignal.timeout(2000) }); const result = { status: response.status, location: response.headers.get('location'), direct200: response.status === 200 }; // Release resources; this check does not need the page body. await response.body?.cancel(); return result; } try { const followed = await fetch(`${origin}/old`, { signal: AbortSignal.timeout(2000) }); assert.equal(followed.status, 200); assert.equal(followed.redirected, true); assert.equal(new URL(followed.url).pathname, '/direct'); await followed.body?.cancel(); console.log('Default fetch: /old -> status 200, redirected true'); const cases = [ ['/direct?source=example#details', 200, null, true], ['/old', 301, '/direct?source=example', false], ['/chain', 302, '/old', false], ['/loop', 307, '/loop', false], ['/missing', 404, null, false] ]; for (const [href, status, location, direct200] of cases) { const actual = await firstHop(href); assert.deepEqual(actual, { status, location, direct200 }); console.log(`${href}: ${actual.status}; direct200=${actual.direct200}`); } await assert.rejects(firstHop('https://example.com/'), /Outside/); console.log('PASS: default-follow check, five first-hop cases, origin guard'); } finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); } What the run actually established
The recorded output was:
Default fetch: /old -> status 200, redirected true /direct?source=example#details: 200; direct200=true /old: 301; direct200=false /chain: 302; direct200=false /loop: 307; direct200=false /missing: 404; direct200=false PASS: default-follow check, five first-hop cases, origin guard The first assertion demonstrates the false shortcut: /old produces a final 200, but redirected is true. The five manual checks distinguish direct success, a permanent redirect, the start of a chain, a self-redirect and a missing URL. The final assertion rejects an input outside the fixture origin before any request is made.
The checker does not follow a Location header. In particular, the /loop test is one request, not an unbounded traversal. It cancels response bodies it does not need and uses a timeout. Assertions stop the run on a mismatch, while the finally block closes the server.
Apply the rule to a link, not just a destination
For an authorised check of a site you maintain, record the source page, the original href and the first response separately. If a replacement is appropriate, verify the intended destination and update that specific link. Do not delete a redirect simply because one internal link no longer needs it; old bookmarks and external references may still depend on it.
Keep query parameters and fragments intentional. In the fixture, the redirect supplies ?source=example; a replacement that drops it would not preserve the same URL. The #details fragment in the direct fixture is not sent in an HTTP request. A 200 therefore says nothing about whether a matching HTML anchor exists. Validate the actual anchor separately.
Use GET when you need to test GET behaviour. A HEAD-only check is a different request and can produce different results on some servers. Conversely, do not casually fetch arbitrary user-supplied URLs: the small origin guard here is tailored to a fixed local fixture, not a complete security design for a public URL-checking service.
Boundaries of this test
This is a Node.js example, not code for a browser console. Browser Fetch can expose manual redirects as opaque responses; do not assume you will be able to read the same status and headers there. Node's built-in fetch uses Undici, whose documentation explains its manual-redirect behaviour.
A direct 200 also does not establish that the content is correct, in the right language, indexable or canonical. It will not detect a JavaScript redirect, a meta-refresh, a soft-404 page or a broken fragment. Those require additional checks. Keep this assertion narrow: for this GET request, the first HTTP response is 200.

