URL Health ❤️‍🩹 — URL & SSL Health Checker (Batch)

Comprehensive URL diagnostics: HTTP status codes, response times, redirect chain analysis, SSL/TLS certificate validation, and content-type detection — for up to 20 URLs in a single run.

Your application's reliability depends on the services it calls. A single failing upstream endpoint can cascade into degraded user experience, broken integrations, and revenue loss. URL Health provides a complete diagnostic check for any URL with zero configuration: it follows redirects, measures response latency, inspects TLS certificates, and detects content types — all with clear, structured output.

Batch up to 20 URLs in a single run for monitoring fleets of endpoints, verifying CDN configurations, or auditing link health across your entire web property. Every result includes a full audit trail: HTTP status code, response time in milliseconds, redirect chain with intermediate status codes, SSL certificate details (issuer, subject, validity period, SANs), server header, and content length.

---

✨ Features

• Batch URL processing — Check up to 20 URLs in a single run with independent diagnostics per URL; individual failures never block the batch
• HTTP status code validation — Returns the exact HTTP status code (200, 301, 404, 500, etc.) for every checked URL, enabling precise monitoring and alerting
• Response time measurement — Precise elapsed time in milliseconds for each request, useful for performance monitoring and SLO tracking
• Redirect chain tracing — Records the full redirect path with source URL, destination URL, and intermediate status codes for every hop — critical for detecting redirect loops and broken intermediates
• SSL/TLS certificate validation — For HTTPS URLs, connects to the origin server, validates the TLS certificate, and returns certificate subject, issuer, validity dates, and Subject Alternative Names (SANs)
• Content-type detection — Reports the Content-Type header from the response, enabling verification of MIME types, charset, and media format expectations
• Content-length measurement — Returns the response body size in bytes for bandwidth planning and response completeness checks
• Server header capture — Records the Server response header for infrastructure fingerprinting and CDN identification
• Configurable timeout — Adjustable per-request timeout (1–60 seconds) for slow endpoints, with graceful timeout error handling
• Redirect following control — Toggle automatic redirect following with the follow_redirects parameter (default: on)

🚀 Quick Start

Single URL — Basic Health Check

Input:

{
  "url": "https://example.com"
}

Batch URL Check — Multiple Endpoints

Input:

{
  "urls": [
    "https://example.com",
    "https://google.com",
    "https://github.com",
    "https://httpstat.us/404",
    "https://httpstat.us/500"
  ],
  "timeout": 10
}

Single URL with SSL Inspection

Input:

{
  "urls": ["https://example.com"],
  "follow_redirects": true,
  "timeout": 15
}

Response:

{
  "url": "https://example.com",
  "http": {
    "url": "https://example.com",
    "status_code": 200,
    "response_ms": 45.2,
    "content_type": "text/html; charset=utf-8",
    "content_length": 1256,
    "server": "ECS (dcb/7EFA)"
  },
  "ssl": {
    "valid": true,
    "hostname": "example.com",
    "subject": {
      "commonName": "example.com",
      "organizationName": "Internet Corporation for Assigned Names and Numbers"
    },
    "issuer": {
      "organizationName": "DigiCert Inc",
      "commonName": "DigiCert TLS RSA SHA256 2020 CA1"
    },
    "not_before": "Jan  1 00:00:00 2026 GMT",
    "not_after": "Jan  1 00:00:00 2027 GMT",
    "sans": ["example.com", "www.example.com"]
  },
  "timestamp": 1712345678.123
}

URL with Redirect Chain

Input:

{
  "urls": ["https://httpstat.us/301"]
}

Response (http section):

{
  "status_code": 200,
  "response_ms": 112.4,
  "content_type": "text/plain",
  "content_length": 0,
  "server": "Microsoft-IIS/10.0",
  "redirects": [
    {
      "from": "https://httpstat.us/301",
      "to": "https://httpstat.us/",
      "status_code": 301
    }
  ],
  "final_url": "https://httpstat.us/"
}

📋 Input Parameters

Parameter	Type	Default	Description
url	string	""	Single URL to check. Alternative to urls array for single-URL usage.
urls	array	[]	Array of URLs to check (up to 20). Overrides url when both are provided.
timeout	integer	10	Request timeout in seconds per URL (range: 1–60).
follow_redirects	boolean	true	Whether to automatically follow HTTP redirects. Disable to check redirect targets explicitly.

📤 Output Format

Each checked URL produces one result row:

Top-Level Fields

Field	Type	Description
url	string	The URL that was checked
http	object	HTTP diagnostics object (see below)
ssl	object	SSL/TLS certificate object (present only for HTTPS URLs)
timestamp	number	Unix timestamp of when the check was performed

HTTP Diagnostics (http object)

Field	Type	Description
url	string	Original URL checked
status_code	integer	HTTP status code (200, 301, 404, 500, etc.)
response_ms	number	Response time in milliseconds
content_type	string	Content-Type response header value
content_length	integer	Response body size in bytes
server	string	Server response header value
redirects	array	Array of redirect objects (only when redirects were followed)
redirects[].from	string	Source URL before redirect
redirects[].to	string	Destination URL after redirect
redirects[].status_code	integer	Intermediate HTTP status code
final_url	string	Final URL after all redirects (only when redirects were followed)
error	string	Error message if the request failed

SSL/TLS Certificate (ssl object)

Field	Type	Description
valid	boolean	Whether a valid TLS certificate was received
hostname	string	Hostname checked
subject	object	Certificate subject fields (commonName, organizationName, etc.)
issuer	object	Certificate issuer fields (commonName, organizationName, etc.)
not_before	string	Certificate validity start date (GMT)
not_after	string	Certificate expiry date (GMT)
sans	array	Subject Alternative Names (DNS names and IPs covered)
error	string	SSL error description if certificate validation failed

A _summary row is appended with total URLs checked, success_count (status < 400), and batch flag.

📖 Usage Examples

cURL (Apify API)

# Single URL
curl -X POST "https://api.apify.com/v2/acts/perryay~url-health/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"url": "https://example.com"}'

# Batch URLs
curl -X POST "https://api.apify.com/v2/acts/perryay~url-health/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"urls": ["https://example.com", "https://google.com"], "timeout": 15}'

Python (Apify SDK)

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

# Check multiple URLs
result = client.actor("perryay~url-health").call(
    run_input={
        "urls": [
            "https://example.com",
            "https://google.com",
            "https://httpstat.us/404",
            "https://self-signed.badssl.com",
        ],
        "timeout": 10,
    }
)
dataset = client.dataset(result["defaultDatasetId"]).list_items()
for item in dataset.items:
    if item.get("_summary"):
        print(f"Summary: {item['success_count']}/{item['total']} healthy")
        continue
    http = item.get("http", {})
    status = http.get("status_code", "?")
    ms = http.get("response_ms", "?")
    err = http.get("error", "")
    print(f"{item['url']} → {status} ({ms}ms)")
    if err:
        print(f"  Error: {err}")
    if item.get("ssl"):
        ssl_valid = item["ssl"].get("valid", False)
        issuer = item["ssl"].get("issuer", {}).get("organizationName", "?")
        print(f"  SSL: {'✅' if ssl_valid else '❌'} (Issuer: {issuer})")

JavaScript / Node.js (Apify SDK)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const result = await client.actor('perryay~url-health').call({
  urls: ['https://example.com', 'https://google.com'],
  timeout: 10,
});

const { items } = await client.dataset(result.defaultDatasetId).listItems();
for (const item of items) {
  if (item._summary) {
    console.log(`Summary: ${item.success_count}/${item.total} healthy`);
    continue;
  }
  const http = item.http || {};
  console.log(`${item.url} → ${http.status_code} (${http.response_ms}ms)`);
  if (item.ssl) {
    console.log(`  SSL Valid: ${item.ssl.valid}`);
  }
}

🎯 Use Cases

• Uptime monitoring — Periodically check critical endpoints (API gateways, SaaS integrations, payment processors) and alert on non-2xx status codes or degraded response times
• CDN and caching verification — Verify that CDN origins, edge nodes, and cached content serve correct status codes, proper content types, and valid SSL certificates across global regions
• SSL certificate expiry tracking — Monitor the not_after field across your entire domain portfolio to proactively renew certificates before they expire and cause browser warnings or service interruptions
• Link rot detection — Scan all external links on your website or documentation for broken URLs (404, 410, 5xx) and maintain link quality over time
• Redirect chain auditing — Audit partner redirect URLs, affiliate links, and URL shorteners to ensure they resolve to the correct destination without unnecessary hops or broken intermediates
• API contract verification — Verify that third-party API endpoints return expected status codes, content types, and response headers after deployments or API version upgrades
• Infrastructure migration validation — After migrating domains, load balancers, or CDN providers, batch-check all affected URLs to confirm the migration completed without errors
• Content-type compliance checking — Ensure all assets on your site serve correct MIME types (e.g., JavaScript as application/javascript, CSS as text/css) to prevent browser warnings and rendering issues

❓ FAQ

Q: How many URLs can I check in one run? A: Up to 20 URLs. Each URL is checked independently, so a timeout or error on one URL never blocks the others.

Q: Does this actor follow redirects? A: Yes, by default. Set follow_redirects: false to disable redirect following and only check the initial URL. When enabled, the full redirect chain is recorded in the redirects array.

Q: What SSL/TLS information is returned? A: The actor performs a real TLS handshake with the origin server and returns certificate subject, issuer organization, validity dates (not_before/not_after), and all Subject Alternative Names (SANs). SSL checks are only performed for https:// URLs.

Q: Can this detect self-signed or expired certificates? A: Yes. If the SSL certificate is invalid (expired, self-signed, wrong hostname), the ssl.valid field will be false and the ssl.error field will contain the specific validation error message.

Q: What response time is considered good? A: For web pages, under 200ms is excellent, 200-500ms is acceptable, and over 1 second needs investigation. For APIs, under 100ms is excellent, 100-300ms is acceptable. The actor reports precise millisecond timing for each request.

Q: How are errors handled during batch processing? A: Each URL is checked independently. Timeouts, connection errors, SSL errors, and invalid URLs are all caught per-URL without affecting other URLs in the batch. The error message is included in the http.error field.

Q: Does this actor support non-HTTP protocols? A: No. Only http:// and https:// URLs are supported. Other protocols (FTP, SSH, SMTP) should use protocol-specific tools.

Q: Can I use this for internal/private endpoints? A: The actor runs on Apify infrastructure. If your private endpoints are not accessible from the public internet, the actor will not be able to reach them. Consider running the actor in a private Apify platform network or using a dedicated proxy.

Q: What does the server header tell me? A: The Server HTTP response header reveals the web server software (nginx, Apache, Cloudflare, ECS, etc.). This is useful for infrastructure fingerprinting and verifying CDN or reverse proxy configuration.

🛠 Tips & Best Practices

• Set appropriate timeouts — Start with the default 10-second timeout and adjust based on your endpoints. Very slow endpoints (over 30 seconds) may indicate performance problems worth investigating separately.
• Monitor SSL expiry proactively — Set up regular batch checks of your domains and alert when days_remaining (computed from ssl.not_after) falls below 30 days. This gives you a full month to handle renewals.
• Use redirect chain for SEO audits — Excessive redirect hops waste page authority and slow down user experience. The redirects array shows every hop — ideally no more than 2 redirects between the initial URL and the final destination.
• Batch strategically — Group URLs by expected latency: check fast CDN-served assets together with a short timeout, and check slower dynamic endpoints with a longer timeout. This prevents slow endpoints from delaying rapid-feedback monitoring.
• Track response times over time — Log response_ms values into a time-series database to establish baselines and detect performance regressions. A sudden 2x increase in response time often indicates upstream issues before they cause failures.
• Combine with other actors — Use this actor in pipelines with SSL Certificate Checker for deep certificate chain analysis, or with Link Quality Analyzer for comprehensive SEO health assessments.
• Validate redirect destinations — The final_url field shows where you actually end up after all redirects. Compare this against your expected destination to catch hijacked redirects, expired URL shorteners, or misconfigured proxies.

🩺 Diagnostic Summary

The _summary row appended at the end of each batch run provides:

{
  "_summary": true,
  "total": 4,
  "success_count": 3,
  "batch": true
}

• total — Number of URLs checked
• success_count — URLs returning HTTP status < 400 (healthy)
• batch — Always true when multiple URLs are checked

Use the ratio success_count / total as a quick service health indicator.

🌐 Protocol and Port Support

Scheme	Supported	SSL Check	Notes
http://	✅	❌	Standard HTTP check, no port restrictions
https://	✅	✅	Full TLS handshake with certificate validation
Port in URL	✅	N/A	Custom ports supported via URL (e.g. https://example.com:8443)

---

🔗 Related Tools

Check out other developer utilities by perryay:

Tool	Description
JSON Studio	Format, validate, transform, and diff JSON data with 8 operation modes
QR Craft	Generate high-quality QR codes in PNG or SVG, batch up to 50
UUID Lab	Generate UUID v4/v7, NanoID, Short ID, and ULID identifiers
Domain Intel	WHOIS, DNS, and SSL lookup for domain intelligence
Meta Mate	Extract Open Graph, Twitter Cards, and JSON-LD metadata
IP Geo	Multi-provider IP geolocation with ISP detection
URL Health	Check URL accessibility, redirects, and SSL health
PW Forge	Generate secure passwords with entropy calculation
TZ Mate	Convert timezones and check DST offsets
Regex Lab	Test and debug regular expressions online
Brand Monitor Lite	Track brand mentions across multiple URLs
Link Quality Analyzer	Detect broken links and audit link quality
Mock Data Generator	Generate realistic test data for development
HTML to Markdown	Convert web pages or HTML to clean Markdown
SSL Cert Inspector	Deep SSL/TLS certificate analysis with scoring