Skip to main content

Website

Checks if a website is alive and returns status code and response time. This node is the foundation of website uptime monitoring, performance tracking, API health checks, and service availability verification.

Common Properties​

  • Name - The custom name of the node.
  • Color - The custom color of the node.
  • Delay Before (sec) - Waits in seconds before executing the node.
  • Delay After (sec) - Waits in seconds after executing node.
  • Continue On Error - Automation will continue regardless of any error. The default value is false.
info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Input​

  • URL - URL of the website to check. If no protocol is provided, https:// is automatically prepended.

Options​

  • Timeout - Timeout in seconds for the HTTP request (default: 60 seconds)
  • Basic Authentication - Optional HTTP Basic Authentication credentials with username and password fields

Outputs​

  • Is Alive - Boolean indicating if website returned a successful 2xx HTTP status code
  • Status Code - HTTP response status code (200, 404, 500, etc.)
  • Response Time - Response time in milliseconds from request start to response received

How It Works​

The Website node sends an HTTP GET request to verify website availability. When executed, the node:

  1. Validates the URL input
  2. Prepends https:// if no protocol is specified
  3. Creates an HTTP client with the specified timeout
  4. Optionally adds Basic Authentication headers if credentials are provided
  5. Sends a GET request and measures response time
  6. Receives the HTTP response
  7. Determines if website is "alive" (2xx status code)
  8. Returns status code, alive status, and response time

HTTP Status Code Reference​

2xx - Success (Is Alive: true)​

  • 200 - OK (Standard successful response)
  • 201 - Created
  • 204 - No Content

3xx - Redirection (Is Alive: false)​

  • 301 - Moved Permanently
  • 302 - Found (Temporary Redirect)
  • 304 - Not Modified

4xx - Client Errors (Is Alive: false)​

  • 400 - Bad Request
  • 401 - Unauthorized
  • 403 - Forbidden
  • 404 - Not Found
  • 429 - Too Many Requests

5xx - Server Errors (Is Alive: false)​

  • 500 - Internal Server Error
  • 502 - Bad Gateway
  • 503 - Service Unavailable
  • 504 - Gateway Timeout

Example Use Cases​

Basic Website Uptime Monitoring​

Check if a website is accessible and responding:

// Input
URL: "https://www.example.com"
Timeout: 30

// Output - Website is up
Is Alive: true
Status Code: 200
Response Time: 245  // 245ms

Performance Monitoring​

Track website response times over time:

// Input
URL: "https://api.example.com"

// Output
Is Alive: true
Status Code: 200
Response Time: 1250  // 1.25 seconds

// Alert if responseTime > 2000ms (performance degradation)

Detect Website Downtime​

Monitor for service outages:

// Input
URL: "https://service.example.com"

// Output - Website is down
Is Alive: false
Status Code: 503
Response Time: 5000

// Status 503 = Service Unavailable
// Send immediate alert to operations team

Monitor Authenticated Endpoints​

Check protected pages with Basic Authentication:

// Input
URL: "https://admin.example.com"
Basic Authentication:
  - username: "admin"
  - password: "secure-password"

// Output - Successfully authenticated
Is Alive: true
Status Code: 200
Response Time: 320

API Health Check​

Verify API endpoints are responding:

// Input
URL: "https://api.example.com/health"

// Output - API is healthy
Is Alive: true
Status Code: 200
Response Time: 85

Multi-Region Availability​

Check website from different regions:

// Run from multiple geographic locations
// Compare response times
// Detect regional outages
// Optimize CDN configuration

Performance Benchmarks​

Response Time Interpretation​

  • < 100ms - Excellent (local or well-optimized)
  • 100-300ms - Good (typical for nearby servers)
  • 300-500ms - Acceptable (remote servers or standard load)
  • 500-1000ms - Slow (investigate optimization)
  • 1000-3000ms - Poor (high load or issues)
  • > 3000ms - Critical (severe performance problems)
  • Fast APIs - 10 seconds
  • Standard Websites - 30 seconds
  • Slow/Large Sites - 60 seconds
  • International Sites - 60-120 seconds

Tips for Effective Use​

  • Protocol Specification - Always specify https:// or http:// for clarity
  • Monitor Complete URLs - Include paths for specific pages (e.g., /login, /api/status)
  • Response Time Trends - Track response time over days/weeks to detect degradation
  • Combine with Keyword - Use Website node for availability, then Keyword node for content verification
  • Status Code Alerts - Different status codes require different actions (404 vs 503)
  • Timeout Configuration - Set timeout based on expected response time + buffer
  • Regular Intervals - Check every 1-5 minutes for critical services
  • Avoid Excessive Requests - Too frequent checks can impact server performance
  • Use Health Endpoints - Create dedicated /health or /status endpoints for monitoring

Common Errors and Solutions​

Error: "URL cannot be empty"​

Cause: The URL input is missing or contains an empty string.

Solution: Ensure the URL input variable contains a valid URL.

Error: "ErrRequest" - Request Failed​

Cause: HTTP request could not be completed.

Solution:

  • Check if URL is correct and accessible
  • Verify network connectivity
  • Confirm the website is online
  • Check for DNS issues (use DNS node)
  • Increase timeout for slow sites
  • Verify firewall settings allow outbound HTTP/HTTPS

Timeout Errors​

Cause: Request exceeded the specified timeout period.

Solution:

  • Increase the Timeout value
  • Check if website is experiencing high load
  • Verify the URL is correct
  • Test website accessibility from browser
  • Check network speed and latency

Status Code: 401 (Unauthorized)​

Cause: Authentication required but not provided or invalid.

Solution:

  • Add Basic Authentication credentials
  • Verify username and password are correct
  • Check if different authentication method is required
  • Confirm credentials have not expired

Status Code: 403 (Forbidden)​

Cause: Server is refusing the request.

Solution:

  • Check if IP is blocked
  • Verify user has necessary permissions
  • Review server access control lists
  • Check if endpoint requires specific headers

Status Code: 404 (Not Found)​

Cause: The requested resource does not exist.

Solution:

  • Verify the URL path is correct
  • Check for typos in the URL
  • Confirm the page exists on the server
  • Review recent deployments that may have removed the page

Status Code: 500 (Internal Server Error)​

Cause: Server encountered an error processing the request.

Solution:

  • Check server logs for error details
  • Verify application is running correctly
  • Review recent code deployments
  • Check database connectivity
  • Contact server administrators

Status Code: 502 (Bad Gateway)​

Cause: Reverse proxy/gateway received invalid response from upstream server.

Solution:

  • Check backend server status
  • Verify proxy configuration
  • Restart reverse proxy (nginx, Apache)
  • Check upstream server connectivity

Status Code: 503 (Service Unavailable)​

Cause: Server is temporarily unable to handle requests.

Solution:

  • Check server capacity and load
  • Verify application is running
  • Review maintenance windows
  • Check for DDoS attacks
  • Scale resources if needed

Integration Examples​

Complete Website Monitoring Solution​

// Every 5 minutes:
// 1. Website node - Check if site is alive
// 2. If isAlive: false
//    - Retry 2 more times (avoid false positives)
//    - If still down: Send alert
// 3. If statusCode >= 500
//    - Alert: Server error
// 4. If responseTime > 3000
//    - Alert: Performance degradation
// 5. Log all metrics to database
// 6. Generate uptime report

Multi-Endpoint Health Dashboard​

// Monitor all critical endpoints
const endpoints = [
  {name: "Homepage", url: "https://www.example.com"},
  {name: "API", url: "https://api.example.com/health"},
  {name: "Admin", url: "https://admin.example.com", auth: true},
  {name: "Mobile API", url: "https://mobile-api.example.com/status"}
];

// For each endpoint:
//   Check with Website node
//   Store: isAlive, statusCode, responseTime
//   Update dashboard
//   Alert on failures

SLA Monitoring and Reporting​

// Calculate uptime percentage
// Total checks: 288 (every 5 min for 24 hours)
// Successful checks: Count where isAlive = true
// Uptime % = (successful / total) * 100

// SLA targets:
//   - 99.9% = 43 minutes downtime/month allowed
//   - 99.95% = 21 minutes downtime/month allowed
//   - 99.99% = 4 minutes downtime/month allowed

// Alert if below SLA threshold

Geographic Performance Comparison​

// Check same URL from multiple regions
const regions = [
  {name: "US East", url: "https://us-east.example.com"},
  {name: "US West", url: "https://us-west.example.com"},
  {name: "EU", url: "https://eu.example.com"},
  {name: "Asia", url: "https://asia.example.com"}
];

// Compare responseTime across regions
// Identify slowest region
// Optimize CDN configuration

Deployment Verification​

// Before deployment
// Check website, record baseline metrics

// After deployment
// 1. Wait 30 seconds for service restart
// 2. Check website
// 3. Verify isAlive: true
// 4. Verify statusCode: 200
// 5. Compare responseTime with baseline
// 6. If any check fails: Trigger rollback
// 7. If all pass: Mark deployment successful

Cascade Failure Detection​

// Check dependent services in order
// 1. Database server
// 2. API service
// 3. Web application
// 4. CDN endpoints

// Track which service failed first
// Identify root cause of cascade
// Alert with dependency tree

API Rate Limit Monitoring​

// Monitor API endpoint
// Track statusCode: 429 (Too Many Requests)
// If 429 detected:
//   - Reduce request frequency
//   - Check API quota
//   - Review rate limiting configuration
//   - Optimize API usage patterns

Scheduled Maintenance Detection​

// Regular monitoring
// If statusCode changes from 200 to 503:
//   - Check for scheduled maintenance
//   - Suppress alerts if maintenance window
//   - Resume normal alerts after window
//   - Verify service recovery

Performance Regression Testing​

// After each deployment:
// Run 10 checks
// Calculate average responseTime
// Compare with previous deployment
// Alert if regression > 20%
// Track performance trends over time

Competitive Website Monitoring​

// Monitor competitor websites
// Track uptime and performance
// Alert when competitor has outage
// Compare your uptime vs competitors
// Generate competitive analysis report

Load Test Validation​

// During load testing:
// Monitor with Website node every 10 seconds
// Track:
//   - When response time increases
//   - When status codes change
//   - When service becomes unavailable
// Identify breaking point
// Validate load test results