Monitoring for Developers

Real-time uptime monitoring for everyone

Ship APIs, side projects, and internal tools with confidence. SitePulse gives you production-grade health checks, instant failure alerts, and zero-config monitoring you can spin up in under two minutes.

Start Monitoring Free Read the API Docs

The Problem

Monitoring shouldn't be a second job

Most developers spend more time configuring Prometheus, wiring up Datadog dashboards, and debugging false-positive alerts than actually building features. If you're shipping APIs or running personal projects, you deserve monitoring that works the way you do.

You learn your API is down from a customer tweet

No health checks, no alerts, no redundancy. Your /v2/invoices endpoint returns 502s for forty-seven minutes and you find out because @jenna_builds posts a screenshot of her broken checkout flow on X.

Local dev feels nothing like production

You test your service on localhost:3000 where everything runs on LAN with zero latency. Then you deploy to a $5 DigitalOcean droplet and suddenly TLS handshakes, cold starts, and rate limits break assumptions you never caught in staging.

Setting up monitoring takes longer than the feature

You want to ship a webhook relay for your side project. Instead, you spend three evenings installing Grafana, writing Loki queries, and fighting with alertmanager routing rules — for a project that earns $42/month in Stripe revenue.

The Solution

Monitoring that fits into your workflow

SitePulse is built for developers who want visibility without the ops overhead. Add an endpoint, pick a channel, and get real-time alerts — no infrastructure to maintain.

API Health Checks Every 60 Seconds

Ping any HTTP(S) endpoint from six global locations. SitePulse validates response codes, TLS certificates, and response time thresholds. If your /healthz endpoint drifts above 800ms or returns a non-2xx status, you get a Slack or Discord notification within 30 seconds.

Local Development Simulation

Run sitepulse simulate --port 3000 and SitePulse injects synthetic latency, randomized timeouts, and TLS errors into your local server. Spot the failure modes in your error-handling path before they hit production.

Personal Project Monitoring, Zero Overhead

Add your side project's endpoint to SitePulse and get a public status badge for your README. Free tier includes 10 monitors, 60-second intervals, and email + webhook alerts. No credit card, no hidden limits, no 14-day trial that locks you out.

Code Examples

Automate your monitoring in minutes

Here's how real developers integrate SitePulse into their projects. Copy, adapt, and ship.

Python: Auto-register a health check endpoint

Use the SitePulse REST API to programmatically add your endpoint whenever you deploy.

import requests

SITEPULSE_API_KEY = "sk_live_7f3a9b2c1d4e8f6a0b5c"
HEADERS = {
    "Authorization": f"Bearer {SITEPULSE_API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "name": "Invoice API — /v2/invoices",
    "url": "https://api.invoicer.io/v2/healthz",
    "interval_seconds": 60,
    "expected_status": 200,
    "max_response_time_ms": 800,
    "alerts": [
        {"channel": "slack", "webhook": "https://hooks.slack.com/services/T04/..."},
    ],
}

response = requests.post(
    "https://api.sitepulse.io/v1/monitors",
    headers=HEADERS,
    json=payload,
)

print(f"Monitor created: {response.json()['id']}")

Bash: Local dev chaos simulation

Stress-test your local Express server by hammering it with randomized delays and injected 5xx responses.

#!/usr/bin/env bash
# simulate.sh — run alongside your local dev server

ENDPOINT="http://localhost:3000/api/status"
DURATION=120  # seconds
INTERVAL=2    # seconds between requests

echo "Starting simulation for ${DURATION}s..."
START=$(date +%s)

while [ $(( $(date +%s) - START )) -lt $DURATION ]; do
  # Randomly inject a timeout (15% chance)
  if [ $(( RANDOM % 100 )) -lt 15 ]; then
    TIMEOUT=5
  else
    TIMEOUT=2
  fi

  HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
    --max-time $TIMEOUT "$ENDPOINT")

  if [ "$HTTP_CODE" -ge 500 ] || [ "$HTTP_CODE" -eq 000 ]; then
    echo "[$(date '+%H:%M:%S')] FAILURE — HTTP $HTTP_CODE"
  else
    echo "[$(date '+%H:%M:%S')] OK — HTTP $HTTP_CODE"
  fi

  sleep $INTERVAL
done

echo "Simulation complete."

GitHub Actions: Deploy-time monitor validation

Fail your CI pipeline if your new deployment doesn't pass SitePulse's health check within 90 seconds of going live.

name: Deploy & Verify Uptime
on:
  push:
    branches: [main]

jobs:
  deploy-and-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Vercel
        run: npx vercel --prod --token ${{ secrets.VERCEL_TOKEN }}

      - name: Wait for SitePulse to confirm uptime
        run: |
          echo "Waiting 30s for cold start..."
          sleep 30

          for i in {1..6}; do
            STATUS=$(curl -s \
              --header "Authorization: Bearer ${{ secrets.SITEPULSE_API_KEY }}" \
              "https://api.sitepulse.io/v1/monitors/m_4821/status")

            echo "Check $i: $STATUS"

            if echo "$STATUS" | grep -q '"state":"up"'; then
              echo "All clear — monitor is healthy."
              exit 0
            fi

            sleep 15
          done

          echo "Monitor still not healthy after 90s — failing CI."
          exit 1