Bulk URL Checker — HTTP Status, Redirects, Response Time & SEO Tags at Scale

Check thousands — or millions — of URLs at once. This bulk URL checker takes a pasted list, an uploaded file, or a remote text/CSV of links and returns, for every URL: HTTP status code, redirect chain, final URL, response time, HTTPS, content type, response size (Content-Length), server, plus the on-page SEO tags — title, meta description, H1, canonical, Open Graph, robots/noindex and word count. No login, no coding, no browser — just fast, structured results you can drop straight into a spreadsheet or pipeline.

Export to JSON, CSV, Excel, or API.

Built for SEO specialists, technical SEO auditors, link builders, QA engineers, webmasters, growth marketers and data teams who need to validate large URL lists, audit redirects, catch broken links, or enrich a list of domains before further work.

---

🔎 Why use a bulk URL checker?

Checking a single URL in a browser is trivial. Checking your entire sitemap, your whole backlink profile, every product page, or a million crawled URLs is a different problem — you need concurrency, retries, redirect resolution, timeout handling and clean, structured output. Doing that by hand, or in a fragile spreadsheet of IMPORTXML formulas, simply does not scale and breaks the moment a server is slow or a page redirects.

This Actor is a purpose-built URL status checker and SEO tag extractor. Point it at a big list of URLs and it returns one tidy row per URL — status code, where it redirected, how fast it responded, and the key SEO signals on the page. Because it runs on plain HTTP via an auto-scaling crawler (no headless browser), it is fast and inexpensive, so even huge lists stay cheap to run.

Common reasons people scrape and check URLs in bulk:

• SEO audits — pull titles, meta descriptions, H1s, canonicals and noindex flags across every page to find missing, duplicate or truncated tags.
• Broken-link / dead-link checks — find every 404, 5xx error, DNS failure and timeout across your links or backlinks.
• Redirect audits — see what redirects where, to which finalUrl, and catch redirect chains or loops before and after a site migration.
• Uptime & health monitoring — track statusCode and responseTimeMs across a list of endpoints on a schedule.
• List enrichment — resolve redirects, drop dead links and normalize a messy list of domains before scraping, outreach or import.
• Content & page-weight checks — spot thin pages via wordCount and heavy responses via contentLength.

---

✨ What this bulk URL checker does

• ✅ Checks any list of URLs — paste them, upload a file, or link a remote text/CSV of URLs. Handles a handful up to millions.
• ✅ Auto-scaling concurrency — processes many URLs in parallel (configurable up to 500) and streams results to the dataset as it goes.
• ✅ Full HTTP status picture — statusCode, a simple healthy/unhealthy ok flag (2xx/3xx), plus error messages for timeouts, DNS failures and connection resets so nothing is silently dropped.
• ✅ Redirect resolution — follows redirects and reports the finalUrl and whether the URL redirected.
• ✅ Performance & transport data — responseTimeMs, isHttps, contentType, contentLength (response size in bytes) and the server header.
• ✅ On-page SEO extraction (toggle with checkSeo) — title, metaDescription, h1, canonical, ogTitle, ogImage, metaRobots, an isNoindex flag and body wordCount.
• ✅ Robust by design — automatic retries, SSL-error tolerance, per-URL timeouts and a dedicated failed-request handler so broken URLs still appear in your results.
• ✅ Scheme-friendly input — bare domains like example.com are automatically upgraded to https://example.com.
• ✅ Export anywhere — JSON, CSV, Excel or the Apify API, and connect to Make, Zapier, n8n or a webhook.

Everything above reflects what the Actor actually does — no JavaScript rendering and no promises of fields the page does not expose.

---

🎯 Use cases

• Technical SEO audits — run a whole sitemap and export titles, metas, H1s, canonicals and noindex flags to find on-page issues at scale.
• Broken-link monitoring — filter by ok: "false" to isolate every 404, 5xx and timeout across your site or link list.
• Backlink validation — check a list of referring URLs to confirm they still exist, still link, and still return 200.
• Site migration QA — compare old URLs' finalUrl and statusCode before and after launch to verify redirects landed correctly.
• Uptime & latency tracking — schedule the Actor over key endpoints and watch statusCode + responseTimeMs over time.
• Lead / domain list cleaning — normalize and de-dead a prospect list before outreach or enrichment.
• Content inventory — use wordCount and contentLength to flag thin or bloated pages across a large catalog.
• Redirect-chain detection — spot URLs that bounce through multiple hops or loop before resolving.

---

📥 Input

Provide the URLs you want to check and, optionally, tune concurrency, timeout and SEO extraction. Everything is optional — leave it empty and the Actor runs a quick demo on a sample of popular sites so you can see the output shape instantly.

Field	Type	Default	Description
urls	array	—	The URLs to check. Paste a list, upload a file, or link a remote text/CSV of URLs (via the request-list source editor). Bare domains are auto-prefixed with https://. Leave empty to run a demo sample.
checkSeo	boolean	true	Also extract on-page SEO tags (title, meta, H1, canonical, Open Graph, robots). Turn off for a pure status/redirect check (faster, lighter).
maxItems	integer	0	Stop after checking this many URLs. 0 = no limit (check every URL you provide).
maxConcurrency	integer	50	How many URLs to check in parallel (1–500). Higher = faster; be considerate of target servers.
timeoutSecs	integer	30	Give up on a URL after this many seconds (3–120).
proxyConfiguration	object	off	Apify Proxy. Off by default — enable it for very large runs or geo-specific checks.

Example input — full SEO audit

{
  "urls": [
    { "url": "https://example.com" },
    { "url": "https://example.com/blog" },
    { "url": "example.com/pricing" }
  ],
  "checkSeo": true,
  "maxConcurrency": 50,
  "timeoutSecs": 30
}

Example input — status-only check (fastest)

{
  "urls": [
    { "url": "https://example.com" },
    { "url": "https://example.com/old-page" }
  ],
  "checkSeo": false,
  "maxConcurrency": 200
}

You can also point the urls field at a remote file of URLs (one per line, or a CSV) using the request-list source option — perfect for very large lists you do not want to paste by hand.

---

📤 Output

You get one record per URL pushed to the dataset as it is checked. Here is a realistic item from a full SEO run:

{
  "url": "https://example.com",
  "statusCode": "200",
  "ok": "true",
  "finalUrl": "https://example.com/",
  "redirected": "false",
  "responseTimeMs": "312",
  "isHttps": "true",
  "contentType": "text/html",
  "contentLength": "1256",
  "server": "ECS",
  "title": "Example Domain",
  "metaDescription": "",
  "h1": "Example Domain",
  "canonical": "",
  "ogTitle": "",
  "ogImage": "",
  "metaRobots": "",
  "isNoindex": "false",
  "wordCount": "28",
  "error": "",
  "scrapedAt": "2026-07-08T15:00:00.000Z"
}

A broken or unreachable URL comes back with ok: "false" and either a status code (404, 500) or an error (timeout, DNS failure), so nothing is silently dropped.

Output field reference

Field	Description
url	The URL you submitted
statusCode	HTTP status code (200, 301, 404, 500…)
ok	"true" if healthy (2xx/3xx), else "false"
finalUrl	URL after following redirects
redirected	"true" if the URL moved
responseTimeMs	Response time in milliseconds
isHttps	"true" if the final URL is HTTPS
contentType	Content type (text/html, application/pdf…)
contentLength	Response size in bytes from the Content-Length header — present when the server sends it
server	Server header — present when the server sends it
title	Page title — present on HTML pages when checkSeo is on
metaDescription	Meta description — present when the page has one
h1	First H1 — present when the page has one
canonical	Canonical URL — present when declared
ogTitle / ogImage	Open Graph title & image — present when declared
metaRobots	Robots meta content — present when declared
isNoindex	"true" if the page is set to noindex
wordCount	Body word count — present on HTML pages when checkSeo is on
error	Error message, if the check failed
scrapedAt	ISO timestamp of the check

SEO fields (title, metaDescription, h1, canonical, Open Graph, metaRobots, wordCount) populate only for HTML pages when checkSeo is enabled — they are intentionally blank for non-HTML responses (PDFs, images, JSON) and for status-only runs. Header fields like contentLength and server are present only when the target server returns them.

---

🔁 Pagination & scale

This Actor is a bulk list processor, not a paginated site crawler — so there is no page/offset/cursor to manage. You hand it the full list of URLs (pasted, uploaded, or linked as a remote text/CSV via the request-list source), and it works through every URL using an auto-scaling HTTP crawler, pushing one de-duplicated record per URL to the dataset as results arrive.

• Scale: comfortably handles hundreds to millions of URLs in a single run. Results stream to the dataset, so you can start reading output before the run finishes.
• Limit: set maxItems to cap how many URLs are checked (0 = no limit).
• Speed: control throughput with maxConcurrency (1–500). On plain HTTP, large runs finish fast and stay inexpensive.
• Termination: the run ends cleanly when the queue drains or the maxItems cap is reached.

---

⚙️ How to use

1. Open the Actor on Apify Console and click Try for free.
2. Paste or upload your URLs (or link a remote text/CSV file).
3. (Optional) Toggle checkSeo, set maxConcurrency, timeoutSecs and maxItems.
4. Click Start and watch records stream in.
5. Export results as JSON, CSV, Excel, or pull them from the Apify API.
6. Automate it: run on a schedule for uptime/SEO monitoring, or wire the output into Make, Zapier, n8n or a webhook.

Run it from the API

curl -X POST "https://api.apify.com/v2/acts/haketa~bulk-url-checker/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": [{"url":"https://example.com"}], "checkSeo": true }'

Then fetch the dataset (CSV example):

$curl "https://api.apify.com/v2/acts/haketa~bulk-url-checker/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv"

---

💡 Tips

• Turn off SEO (checkSeo: false) for pure link-checking — much faster and cheaper on huge lists.
• Raise maxConcurrency for speed on big runs, but keep it reasonable toward the target servers you are hitting.
• Filter the output: on ok / statusCode to isolate broken URLs, on redirected for migration checks, on isNoindex for indexation issues, and on wordCount / contentLength for thin or heavy pages.
• Enable Apify Proxy for very large runs, to avoid rate limits from a single IP, or to check geo-specific responses.
• Use a remote file for very large URL lists instead of pasting thousands of lines.
• Schedule it to turn the Actor into a lightweight uptime and SEO-regression monitor.

---

❓ FAQ

Is it legal to check URLs in bulk with this scraper? The Actor performs standard HTTP requests to the URLs you provide and reads publicly returned headers and HTML — the same thing your browser does. Only check URLs you have the right to check, respect robots and terms, and be considerate with concurrency toward target servers.

How many URLs can it handle and how fast is it? From a handful to millions. It auto-scales concurrency (up to 500 parallel requests) and streams results to the dataset, so hundreds of URLs finish in seconds and very large lists run cheaply on plain HTTP.

Does it follow redirects? Yes. finalUrl is the destination after redirects and redirected tells you whether the URL moved — ideal for redirect and migration audits.

Does it render JavaScript? No. It uses fast HTTP fetching and reads the server-rendered HTML (title, meta, canonical, etc.). This keeps large runs cheap, but content injected purely by client-side JavaScript will not appear.

Do I need a proxy or a login? No login is ever required. A proxy is off by default and optional — enable Apify Proxy only for very large runs, to dodge single-IP rate limits, or for geo-specific checks.

Which export formats and is there an API? Export to JSON, CSV, Excel or JSON Lines, and pull results via the Apify API. You can also trigger runs and read datasets programmatically, or connect to Make, Zapier, n8n and webhooks.

How fresh is the data? Every record is captured live at run time — scrapedAt records the exact moment each URL was checked. Schedule the Actor to keep a fresh view of status and SEO tags.

Can I do a status-only check without the SEO tags? Yes — set checkSeo: false for a faster, lighter run that returns status, redirects, timing and headers only.

What happens to broken or unreachable URLs? They are included, never dropped — with ok: "false" and either a status code (404, 500) or an error message (timeout, DNS failure).

Can I limit how many URLs it checks? Yes — set maxItems to any number; 0 means check every URL you provide.

Why are some SEO fields empty? SEO fields only populate for HTML pages when checkSeo is on. Non-HTML responses (PDFs, images, JSON) and status-only runs leave them blank by design. Header fields like contentLength and server appear only when the server sends them.

---

🔗 Related scrapers

• Bulk Metadata Extractor — pull titles, meta tags and Open Graph data from any list of pages.
• OutSEO Scraper — SEO data and insights for keyword and competitor research.
• Google Trends Scraper — track search interest and trending topics over time.
• Google Play Scraper — scrape app listings, ratings and reviews from Google Play.
• App Store Scraper — extract app metadata, ratings and reviews from the Apple App Store.
• Marktplaats Scraper — scrape listings and prices from Marktplaats.

---

Ready to audit your URLs? Click Try for free, paste your list, and get one clean row per URL — status, redirects, timing and SEO tags — exported to JSON, CSV, Excel or API in seconds.