URL Status & Redirect Checker

Check up to 100,000 URLs in one run and see which ones work, which ones are broken, which ones redirect and where they finally land. For every URL you get the HTTP status code, the full redirect chain hop by hop, the final URL, the response time and a clear error code when something fails. Built for SEO specialists, web developers, agencies and anyone who has a list of links to verify.

What is URL Status & Redirect Checker?

URL Status & Redirect Checker is a bulk HTTP status code checker that runs on the Apify platform. You paste a list of URLs (or send it through the API), and the Actor requests each one, follows every redirect by hand and reports what happened. It answers questions like:

• Do all the old URLs from my previous site still redirect after the migration?
• Which links in this list return 404, 410 or a server error?
• Does this URL redirect in one hop, or through a chain of three redirects?
• Where does this short link or tracking link really end up?
• Is the final page served over HTTPS?

It is a polite client: it reads each site's robots.txt and respects it, sends only one request at a time to the same host with a pause in between, identifies itself with an honest user agent and never downloads page content. It works with headers only.

What does it check?

For every URL in your list you get:

• HTTP status code of the final response (200, 301, 404, 410, 500, 503, ...).
• ok flag: true when the final status is a 2xx success code.
• Redirect count and the full redirect chain: every hop with its URL and status code (301, 302, 303, 307, 308).
• Final URL: the address the URL ends up at after all redirects.
• HTTPS flag: whether the final URL uses HTTPS.
• Response time in milliseconds, summed over all hops.
• Content type of the final response (for example text/html or application/pdf).
• Error code and error detail when the URL could not be checked: timeouts, DNS errors, TLS (SSL certificate) errors, refused connections, protocol errors, redirect loops, URLs blocked by robots.txt, invalid URLs and addresses that are not on the public internet.
• Timestamp of the check (UTC).

Use cases

• Site migrations and relaunches: export the URL list of the old site, run it after the switch and confirm that every old URL answers with a 301 or 308 to the right new page, in one hop, ending on a 200.
• Broken link checks for a URL list: check the outbound links of an article database, a link directory, a product feed or a spreadsheet of backlinks for 404, 410 and 5xx answers.
• Redirect checker for SEO audits: find redirect chains (several hops) and redirect loops that waste crawl budget and slow visitors down, and see which hops use temporary (302, 307) instead of permanent (301, 308) redirects.
• HTTP to HTTPS checks: put the http:// version of your important URLs in the list and confirm that each one ends on HTTPS.
• Monitoring important pages: schedule a daily or hourly run with your key landing pages, checkout pages or API endpoints and get notified through a webhook or an integration when one stops answering with 200.
• Cleaning link lists before outreach or ads: check the destination URLs of campaigns, QR codes or short links before they go live, and see where each one really lands.
• Checking a whole site's URLs: combine it with the Sitemap URL Extractor & Validator: extract every URL from the sitemaps first, then check all of them here.

How to use URL Status & Redirect Checker

1. Open the Actor in Apify Console (click Try for free or Start on this page).
2. Paste your URLs into the URLs field, one per line. https:// is added when a URL has no scheme.
3. Optionally adjust the maximum number of redirects, the timeout, the number of parallel requests and the delay per host.
4. Set a maximum cost per run in the run options if you want a hard spending limit. The checker stops at that limit.
5. Click Start and watch the status message: it shows how many URLs are checked so far.
6. When the run finishes, open the Output tab and download the results as JSON, CSV, Excel, XML or HTML, or read them through the API.
7. To repeat the check regularly, create a Schedule for the Actor (or for a saved task with your URL list) in Apify Console.

Input

Field	Type	Default	What it does
urls	array of strings	(required)	The URLs to check.
maxRedirects	integer, 0 to 20	10	How many redirects to follow before the URL counts as a redirect loop.
timeoutSecs	integer, 5 to 60	15	How long to wait for each response, in seconds.
maxConcurrency	integer, 1 to 50	10	How many URLs are checked at the same time.
perHostDelayMs	integer, 200 to 10,000	500	Pause between two requests to the same host, in milliseconds.

Tips for each field:

• urls: one URL per line in the Console. A URL without a scheme (example.com/page) is checked as https://example.com/page. Exact duplicates are checked once. Only http and https URLs are checked, and URLs with a user name or password in them are refused. Up to 100,000 URLs per run are checked; further entries are ignored, so split bigger lists into several runs. Through the API you can also pass objects such as {"url": "https://..."} instead of strings, so the output of another Actor can be fed in directly.
• maxRedirects: the default of 10 is enough for almost every real redirect chain. When a URL needs more hops than this, it is reported with the error too_many_redirects, which is also how redirect loops show up. With 0, every URL that redirects is reported as too_many_redirects.
• timeoutSecs: raise it for slow servers; lower it to finish faster on lists with many dead hosts. Connecting to a host waits at most 10 seconds, whatever you set here.
• maxConcurrency: this is the number of URLs in flight across different hosts. Each host still gets only one request at a time, so a list with many different hosts profits from a higher value, while a list on a single host does not get faster.
• perHostDelayMs: the polite pause between two requests to the same host. If the site's robots.txt asks for a longer crawl delay, that one applies (up to 30 seconds).

Example input:

{
  "urls": [
    "https://example.com/",
    "http://example.com/old-page",
    "example.org/contact"
  ],
  "maxRedirects": 10,
  "timeoutSecs": 15,
  "maxConcurrency": 10,
  "perHostDelayMs": 500
}

Output

The Actor writes one dataset item per URL, in the order of your input. A URL that redirects twice and ends on a working page looks like this:

{
  "url": "http://example.com/old-page",
  "ok": true,
  "status": 200,
  "final_url": "https://example.com/new-page",
  "redirects": 2,
  "redirect_chain": [
    {"url": "http://example.com/old-page", "status": 301},
    {"url": "https://example.com/old-page", "status": 308}
  ],
  "response_ms": 412,
  "content_type": "text/html",
  "https": true,
  "error": "",
  "error_detail": "",
  "checked_at": "2026-10-18T09:00:00Z"
}

A URL whose host does not exist looks like this:

{
  "url": "https://old-campaign.example.net/",
  "ok": false,
  "status": null,
  "final_url": null,
  "redirects": 0,
  "redirect_chain": [],
  "response_ms": null,
  "content_type": null,
  "https": true,
  "error": "dns_error",
  "error_detail": "old-campaign.example.net does not resolve",
  "checked_at": "2026-10-18T09:00:02Z"
}

Output fields

Field	Type	Meaning
url	string	The checked URL, cleaned up: scheme and host in lower case, / added when the path is empty, the #fragment removed. For invalid input, the text as you entered it (trimmed, at most 2,000 characters).
ok	boolean	true when the final status code is between 200 and 299.
status	integer or null	Status code of the final response; null when the URL could not be checked.
final_url	string or null	Where the URL ends up after all redirects; null on errors.
redirects	integer	Number of redirects followed.
redirect_chain	array	Every redirect hop as {url, status}, in order. The final response is not part of the chain.
response_ms	integer or null	Response time in milliseconds, summed over all hops. The polite waiting time between requests is not included.
content_type	string or null	Content type of the final response without parameters such as charset.
https	boolean	Whether the final URL (or, on errors, the checked URL) uses HTTPS.
error	string	Empty when the check worked, otherwise one of the error codes below.
error_detail	string	A short explanation of the error (at most 300 characters).
checked_at	string	When the URL was checked, in UTC (ISO 8601).

Error codes

Code	Meaning
timeout	The server did not answer within the timeout.
dns_error	The host name does not resolve.
tls_error	The HTTPS connection failed, for example because of an invalid or expired SSL certificate.
connection_error	The connection was refused or broke off.
protocol_error	The server sent an answer that is not valid HTTP.
http_error	Another HTTP-level failure.
too_many_redirects	More redirects than maxRedirects: a redirect loop or a very long chain.
blocked_by_robots	The site's robots.txt does not allow automated clients on this path, so the URL was not requested.
robots_unavailable	The site's robots.txt answered with a server error, so nothing on that site is requested.
invalid_url	Not a valid http(s) URL, or a URL with a user name or password.
not_public_address	The host points to a private, local or otherwise non-public network address.
internal_error	An unexpected problem in the checker with this one URL; the rest of the run goes on.

When a site's robots.txt cannot be fetched at all, the URLs on that site show the reason, for example timeout or connection_error.

Dataset view

The Overview table in the Output tab shows url, ok, status, redirects, final_url, response_ms and error, so broken and redirecting URLs stand out at a glance. The full items, with the redirect chain and all other fields, are in every export.

How it works

1. The URL is cleaned up and checked: only http(s), no credentials, public addresses only.
2. The site's robots.txt is read once per site and run, and its rules for our user agent are applied (RFC 9309: longest matching rule wins, * and $ patterns supported).
3. The checker sends a HEAD request. Redirects are followed one by one, and every hop is checked again for robots.txt and public addresses.
4. Servers that answer HEAD badly (with 400, 403, 404, 405, 406, 429, 500, 501, 502 or 503) get one GET request instead, whose body is never read. The result of that GET is reported.
5. The result is written to the dataset in the order of your input.

How much does it cost?

This Actor uses pay-per-event pricing: you pay USD 0.001 per URL checked (USD 1 per 1,000 URLs), plus Apify's standard actor start event of USD 0.00005 per run. With pay-per-event pricing the platform usage of the run is included in these prices.

URLs checked	URL events	Actor start	Total per run
100	USD 0.10	USD 0.00005	USD 0.10005
1,000	USD 1.00	USD 0.00005	USD 1.00005
10,000	USD 10.00	USD 0.00005	USD 10.00005
100,000	USD 100.00	USD 0.00005	USD 100.00005

What is charged and what is free:

• Charged: every URL the checker looked up or requested, whatever the answer: 200, 404, a redirect loop, a timeout, a DNS error, or a URL that robots.txt disallows (the checker had to read robots.txt to know).
• Free: invalid URLs (invalid_url), addresses that are not on the public internet (not_public_address) and URLs that failed with internal_error. They are listed in the results so you can see them, but they are not charged.

Set a maximum cost per run and the checker respects it: if your limit covers fewer URLs than your list has, only the first ones are checked, and the run stops at your limit. Apify's free plan includes monthly platform credit, which you can use to try the Actor.

Tips and best practices

• Mix hosts for speed. Each host gets one request at a time with a pause in between, so a list spread over many sites finishes much faster than the same number of URLs on one site. At the default delay, one host gets at most two requests per second.
• Large lists on one site take time. 10,000 URLs on one host need at least 10,000 × 0.5 seconds at the default delay, more with a crawl delay in robots.txt. Give such runs a longer run timeout in the run options.
• Check both protocol versions. Add the http:// and the https:// form of key URLs to see both redirect paths.
• Filter the export. In a CSV or Excel export, filter ok = false for broken URLs, redirects > 1 for redirect chains, and https = false for pages that end on HTTP.
• Allow the checker on your own site. The checker obeys the robots.txt rules for the product token HelveticLabs-WebCheck. If your own site blocks bots, add a group User-agent: HelveticLabs-WebCheck with Allow: / to check it.
• Save a task. Save your URL list and settings as an Apify task, then schedule the task and connect a webhook or an integration to act on the results.

Limitations

• It checks the URLs you give it; it does not crawl pages or find links inside them. For that, use the Website Health Audit.
• It works with headers only and never reads page content, so it cannot detect "soft 404" pages that answer 200 with an error message.
• Pages that robots.txt disallows are not requested. When a site's robots.txt answers with a server error, nothing on that site is requested, as RFC 9309 requires.
• It runs without JavaScript, so redirects that happen in the browser (JavaScript or meta refresh) are not followed; only HTTP redirects are.
• Some servers answer automated clients differently from browsers, for example with 403 or 429. The checker reports the answer it got.
• Only public addresses are contacted; intranet and local URLs are refused.
• Up to 100,000 URLs per run.

FAQ

Is it legal to use? The checker requests public URLs the way a browser or a search engine would, reads only status codes and headers, and respects robots.txt. Check only sites you own or may check, and see the fair use rules at the end of this page.

Does it respect robots.txt? Yes, for every request, including every redirect hop. URLs that robots.txt disallows are reported as blocked_by_robots and not requested. A crawl delay in robots.txt slows the checker down for that host.

Does it store personal data? No. It returns status codes, URLs and header facts only, never page content. Your input and results stay in your Apify account.

How fast is it? That depends on the servers and on how many hosts your list covers. Up to maxConcurrency URLs on different hosts are checked at the same time; each host gets one request at a time, at least perHostDelayMs apart.

Can I schedule it? Yes. Create a schedule in Apify Console for the Actor or for a saved task, for example daily for your key pages.

Can I use it from Python, JavaScript or the API? Yes, see the Integrations section below.

Can AI agents use it? Yes, through Apify's MCP server, which lets AI agents and MCP clients call Apify Actors as tools.

Why was a URL not charged? Invalid URLs, addresses that are not public and URLs that failed with an internal error are free. Everything that was looked up or requested is charged.

Why do I see blocked_by_robots? The site's robots.txt does not allow automated clients on that path, and this checker respects that.

How is it different from a browser extension or a one-URL-at-a-time online checker? It checks thousands of URLs in one run, follows each redirect hop by hop, returns structured data you can export or process automatically, and can run on a schedule without your computer.

What happens on errors and timeouts? A URL that fails gets an item with an error code; the run goes on with the next URL. If the whole run reaches its run timeout, Apify stops it, and the results written up to then stay in the dataset.

Does it check links inside the pages? No, it checks the URLs you give it. To get all URLs of a site first, use the Sitemap URL Extractor & Validator; to crawl a site and find broken links on its pages, use the Website Health Audit.

Integrations

You can run the Actor from Apify Console, through the Apify API, or from your own code. The actor ID is HelveticLabs/url-status-checker.

Python (pip install apify-client):

from decimal import Decimal

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("HelveticLabs/url-status-checker").call(
    run_input={
        "urls": ["https://example.com/", "http://example.com/old-page"],
        "maxRedirects": 10,
        "timeoutSecs": 15,
    },
    max_total_charge_usd=Decimal("5"),  # optional spending limit for this run
)
# apify-client 3.x; with older versions use run["defaultDatasetId"]
for item in client.dataset(run.default_dataset_id).iterate_items():
    if not item["ok"]:
        print(item["url"], item["status"], item["error"])

JavaScript (npm install apify-client):

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('HelveticLabs/url-status-checker').call(
    { urls: ['https://example.com/', 'http://example.com/old-page'], maxRedirects: 10 },
    { maxTotalChargeUsd: 5 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((item) => !item.ok));

HTTP API: start a run with POST https://api.apify.com/v2/acts/HelveticLabs~url-status-checker/runs and your input as the JSON body; maxTotalChargeUsd as a query parameter caps the cost of the run.

No-code and automation: connect the Actor to Make, Zapier or n8n, or add a webhook that calls your endpoint when a run finishes, for example to post broken URLs to a chat channel or a spreadsheet.

AI agents (MCP): Apify's MCP server lets AI agents and MCP clients find and run this Actor as a tool. Pass maxTotalChargeUsd in the call options to cap what an agent can spend.

Related HelveticLabs actors

Actor	What it does
Website Health Audit: Broken Links & SEO Checker	Crawls a site: broken links, redirects, titles, descriptions, H1 and sitemap gaps, with a score per page.
Sitemap URL Extractor & Validator	Every URL from a site's sitemaps, with lastmod dates and a validation report.
Website Security Headers & TLS Audit	A+ to F security grade: HTTPS, security headers, SSL certificate, SPF and DMARC.
AI Crawler Access Checker	Which AI bots (GPTBot, ClaudeBot, PerplexityBot, ...) a site's robots.txt allows, plus llms.txt.

Support and feedback

Found a bug, a wrong result or missing a feature? Open an issue in the Issues tab on this Actor's page, or write to contact@helveticlabs.org. Please include the run ID if a run is involved, so we can look at the same data.

Provider, privacy and fair use

Provider: HelveticLabs, sole proprietorship of Marvin Krieg, c/o SwissMailBox 170, 12 Rue Le Corbusier, 1208 Genève, Switzerland. E-mail: contact@helveticlabs.org. Imprint: https://www.helveticlabs.org/imprint

Privacy: This Actor runs on the Apify platform, in your Apify account. It processes only the URLs or domains you enter and the public technical data the checked servers return (status codes, headers, certificates, DNS records, sitemap URLs, links). It does not collect personal data: it never stores or returns page text (where a page's HTML is read, it is read in memory only, to find links and measure tags), and it leaves out e-mail addresses, cookie names and values and similar values. Your input and results stay in your Apify account and are stored by Apify under its own terms (https://apify.com/privacy-policy). The provider sees only the usage statistics Apify shows to Actor authors (such as the number of users and runs), not your input or results, unless you share a run for support. Questions about privacy: contact@helveticlabs.org.

Fair use: Check only sites you own or may check. Do not use the results to attack systems or people. The Actor respects robots.txt, identifies itself, and keeps a polite pace per site.

No warranty: The results are automated checks and can be incomplete. They are not a penetration test, legal advice or a compliance certificate.