Uptime Monitoring for Insomnia REST Client Services 2026

Insomnia is a powerful REST, GraphQL, and gRPC client used by developers to design, debug, and test APIs. But like any API client, Insomnia tests your APIs on demand — it doesn't watch them 24/7.

By the end of this guide you'll have continuous uptime monitoring for every service in your Insomnia workspace, heartbeat alerts for CI pipelines running Inso CLI, and instant notifications when something breaks — free.

What Insomnia doesn't do for you

Insomnia sends requests when you click Send. Your services can go down between requests and you won't know until your next manual test or a customer reports an error.

The monitoring gap:

• You open Insomnia Monday morning to debug a feature
• A request fails
• You spend 20 minutes debugging your code before realizing the service has been down since Friday

External uptime monitoring catches failures as they happen — not when a developer notices them.

Step 1: Add a health endpoint to each service in your workspace

For each API service in your Insomnia workspace, add a /health endpoint that reflects real dependency status. This is what Vigilmon will probe.

Python / Flask:

# app.py
from flask import Flask, jsonify
import psycopg2
import os

app = Flask(__name__)

@app.route('/health')
def health_check():
    checks = {}

    try:
        conn = psycopg2.connect(os.environ['DATABASE_URL'], connect_timeout=3)
        conn.close()
        checks['database'] = {'status': 'ok'}
    except Exception as e:
        checks['database'] = {'status': 'error', 'detail': str(e)}

    all_ok = all(c['status'] == 'ok' for c in checks.values())
    status_code = 200 if all_ok else 503

    return jsonify({
        'status': 'ok' if all_ok else 'degraded',
        'checks': checks,
    }), status_code

Go:

// handlers/health.go
package handlers

import (
    "database/sql"
    "encoding/json"
    "net/http"
)

type HealthResponse struct {
    Status string            `json:"status"`
    Checks map[string]Check  `json:"checks"`
}

type Check struct {
    Status string `json:"status"`
    Detail string `json:"detail,omitempty"`
}

func HealthCheck(db *sql.DB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        checks := map[string]Check{}

        if err := db.Ping(); err != nil {
            checks["database"] = Check{Status: "error", Detail: err.Error()}
        } else {
            checks["database"] = Check{Status: "ok"}
        }

        allOk := true
        for _, c := range checks {
            if c.Status != "ok" {
                allOk = false
                break
            }
        }

        status := "ok"
        httpStatus := http.StatusOK
        if !allOk {
            status = "degraded"
            httpStatus = http.StatusServiceUnavailable
        }

        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(httpStatus)
        json.NewEncoder(w).Encode(HealthResponse{Status: status, Checks: checks})
    }
}

Add the health request to your Insomnia workspace so your team can test it manually and you have a consistent reference point for the monitored URL.

Step 2: Set up external HTTP monitoring with Vigilmon

With your health endpoints live, point Vigilmon at each service:

1. Sign up at vigilmon.online — free tier, no credit card
2. Click New Monitor → HTTP
3. Enter https://yourservice.com/health
4. Set the check interval (5 minutes on free tier)
5. Save

Create monitors that mirror your Insomnia environments:

| Insomnia Environment | Vigilmon Monitor | |---|---| | Production | https://api.yourdomain.com/health | | Staging | https://staging.api.yourdomain.com/health | | Local (tunneled) | https://yourname.ngrok.io/health (optional) |

Now if a service goes down, Vigilmon catches it from multiple regions — not just from wherever you're sitting when you open Insomnia.

Step 3: Heartbeat monitoring for Inso CLI pipelines

Inso is Insomnia's CLI tool for running request collections in CI/CD. If your pipeline stops running — a runner is down, a cron is misconfigured, a spec validation starts failing — you want to know.

In Vigilmon:

1. Click New Monitor → Heartbeat
2. Set the expected interval (e.g. 25 hours for a daily run)
3. Copy the ping URL

GitHub Actions with Inso:

# .github/workflows/api-tests.yml
name: API Tests with Inso

on:
  schedule:
    - cron: '0 7 * * *'
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Inso CLI
        run: npm install -g insomnia-inso

      - name: Run API tests
        run: |
          inso run test "Test Suite Name" \
            --env "Production" \
            --ci

      - name: Ping heartbeat on success
        if: success()
        run: curl -fsS "${{ secrets.INSO_HEARTBEAT_URL }}"

GitLab CI:

inso-tests:
  stage: test
  image: node:20
  before_script:
    - npm install -g insomnia-inso
  script:
    - inso run test "Test Suite Name" --env Production --ci
  after_script:
    - |
      if [ "$CI_JOB_STATUS" == "success" ]; then
        curl -fsS "$INSO_HEARTBEAT_URL"
      fi
  only:
    - schedules

Add INSO_HEARTBEAT_URL to your CI secrets. If your Inso pipeline stops pinging within 25 hours, Vigilmon fires an alert — even if the service itself is up.

Step 4: Monitor GraphQL and gRPC endpoints

Insomnia supports GraphQL and gRPC — both common in modern microservice architectures. Vigilmon can monitor them too.

GraphQL health check:

GraphQL APIs don't have a standard health endpoint, but you can add one:

// Express + Apollo Server
app.get('/health', async (req, res) => {
  try {
    // Run a cheap introspection query
    const result = await server.executeOperation({
      query: '{ __typename }',
    });
    if (result.errors) throw new Error(result.errors[0].message);
    res.json({ status: 'ok' });
  } catch (err) {
    res.status(503).json({ status: 'error', detail: err.message });
  }
});

Or monitor your GraphQL endpoint directly with a POST monitor in Vigilmon:

• Method: POST
• URL: https://api.yourdomain.com/graphql
• Body: {"query": "{ __typename }"}
• Expected status: 200

gRPC health check:

Use the standard gRPC Health Checking Protocol and expose an HTTP proxy:

# Monitor the gRPC gateway health endpoint
https://api.yourdomain.com/grpc.health.v1.Health/Check

Step 5: Alert routing for your team

Configure where Vigilmon sends alerts in Notifications → New Channel:

Slack — post to #incidents:

Channel: #incidents
Alert: 🔴 DOWN: api.yourdomain.com/health | Status: 503 | Regions: US-East, EU-West
Recovery: ✅ RECOVERED: api.yourdomain.com/health | Downtime: 12 min

PagerDuty — for on-call rotation:

1. Create a Vigilmon integration in PagerDuty
2. Copy the integration key
3. In Vigilmon: Notifications → New Channel → PagerDuty
4. Paste the key

Email — for low-urgency alerts: Add team email addresses to get notified without requiring a Slack or PagerDuty account.

Step 6: Public status page

Give your users transparency during incidents:

1. Status Pages → New Status Page
2. Name it (e.g. "API Platform Status")
3. Add your production monitors
4. Link to it from your API documentation

For Insomnia-driven development, export your workspace spec as OpenAPI and include the status page URL in the info.x-status-page field — some documentation generators surface it automatically.

What you've built

| What | How | |---|---| | Service health endpoints | /health per service with dependency checks | | External uptime monitoring | Vigilmon HTTP monitors aligned to Insomnia environments | | Inso CLI heartbeats | Ping on CI success; missed ping triggers alert | | GraphQL / gRPC monitoring | HTTP proxy or introspection endpoint | | Instant alerts | Slack, PagerDuty, or email notifications | | Public status page | Linked from API documentation |

Insomnia tells you how your APIs behave when you test them. Vigilmon tells you whether they're available when you're not looking. Both are essential for a production API team.

Get started free at vigilmon.online — your first monitor is running in under a minute.