Docs > Getting Started > Getting Started with Monitors
Getting Started with Monitors
Overview
This guide introduces AppStatus Monitors and covers:
- Monitor types: HTTP, API, Port, and Ping
- SSL certificate monitoring and domain expiry tracking
- Multi-region probing from 70 global locations
- HTTP validation: status codes, response body, headers
- Alert email configuration and incident automation
- Real-time diagnostics and uptime history
What are AppStatus Monitors?
Monitors continuously check the health and availability of your endpoints, services, and infrastructure. They evaluate HTTP responses, TCP port connectivity, SSL certificate validity, and ICMP reachability from multiple global regions and generate state changes that drive alert routing, status communication, and incident workflows.
AppStatus supports four monitor types — HTTP, API, Port, and Ping — each with configurable intervals, timeouts, validation rules, and per-region probe distribution. When a monitor detects a failure, it automatically creates an incident, dispatches alerts through configured notification channels, and updates linked status pages.
Key capabilities:
- 70 global probe regions across North America, South America, Europe, Asia Pacific, Middle East, and Africa
- SSL certificate monitoring with configurable expiry alerts (1–365 days before expiry)
- HTTP validation: expected status codes, response body contains, custom headers
- Real-time diagnostics: DNS resolve, TCP connect, TLS handshake, time to first byte
- Uptime history with 90-day retention and daily summary aggregation
- Pause/resume monitors without deleting configuration
Monitor Workflows
Each workflow maps to real AppStatus features and API endpoints used in the main app.
Create Monitor
Monitors are configured from the `/monitors/create` workflow in the main app and saved with explicit endpoint, region, and alert targets.
- Choose monitor type: http, api, port, or ping.
- Set name, endpoint URL/host, probe interval, timeout, and at least one region.
- Set HTTP validation fields when applicable: method, expected status codes, response contains, and expected headers.
- Add unique valid alert email recipients before submit.
Troubleshooting
Monitor shows DOWN but service is up
Check if the expected status code and response body match your endpoint. Verify the URL is accessible from external networks. Review the regions — some regions may have network restrictions. Use the Diagnostics tab to see DNS/TCP/TLS breakdown.
SSL certificate alerts not firing
Ensure enableSslCheck is true and sslAlertDaysBeforeExpiry is set. SSL checks run once per day with deduplication (36-hour Redis TTL). Only HTTPS URLs are checked. Use the manual SSL check endpoint to verify.
Response time is high in some regions
This is expected for geographically distant regions. Use the Region Map to compare latency across 70 probe locations. Consider adding a CDN or regional deployments for latency-sensitive endpoints.
Too many false positive alerts
Increase the failThreshold (number of consecutive failures before alert). Adjust the timeout for slow endpoints. Review expectedStatusCodes — ensure redirect codes are included if followRedirects is disabled.
Monitor incidents not appearing on status page
Ensure the monitor is mapped to a status page component in the Structure tab. Check min_incident_length filter — short incidents may be hidden. Verify show_incidents is enabled on the status page.
Operational Guidance
- Avoid one monitor serving too many unrelated dependencies.
- Tag monitors by service and owner for traceability.
- Review noisy checks monthly and tune thresholds.
Step-by-Step Setup
A monitor is a recurring health check against one URL or host. You set the target, pick how often to check it, choose which regions to check from, and tell AppStatus how to recognise a healthy response. The dashboard then shows live status, uptime history and any incidents the monitor opens.
Before you start
- A free AppStatus account (sign up at auth.appstatus.io/register)
- The URL or host you want to monitor — for example https://example.com/health
- At least one notification channel already created (or you can add one during this flow)
- 1
Open the Monitors section
Sign in to the app and use the left-hand sidebar to navigate to Monitors. This is the home for every uptime check in your workspace — both healthy and failing.
WhereSidebar → Monitors - 2
Click "Create new check"
The Create Monitor form opens on the right. The form is grouped into three sections — Basics, Validation and Alerting — so you can fill it top-to-bottom in one go.
WhereMonitors → Create new check (top-right button) - 3
Pick the check type
Choose what kind of check this is. HTTPS is the right default for most websites and APIs; the other types are for lower-level health checks where HTTP is not appropriate. See the options table below for what each one means.
WhereBasics → Check type - 4
Fill in the target and timing
Give the monitor a clear name (it shows up everywhere), enter the URL or host, choose how often the check should run, and how long to wait for a response before giving up. Smaller intervals catch outages faster but use more of your plan quota.
WhereBasics → Name, URL, Check interval, Timeout - 5
Choose probe regions
Tick one or more regions where the check will run from. A single failed check from one region is treated as a soft warning; AppStatus only opens a real incident when multiple regions agree the target is down. Pick at least the region closest to your users; pick three or more for production traffic.
WhereBasics → RegionsTipThe number of regions you can select is bounded by your plan — see the Pricing page for limits.
- 6
Set the validation rules
Tell AppStatus what counts as a healthy response. By default any 2xx status code is considered UP. You can tighten this by requiring a specific status code, or by requiring a token to appear in the response body (great for "I check that the page actually says 'healthy' in it" patterns).
WhereValidation → Expected status code, Expected response contains, Follow redirects, Verify SSL - 7
Attach alert channels
Under Alerting, pick one or more notification channels (Email, Slack, SMS, Webhook, etc.) where DOWN and RECOVERY notifications should go. If you have not created a channel yet, click "+ Create channel" right from this dropdown — see the Alerts guide for the channel walkthrough.
WhereAlerting → Notification channelsTipYou can attach more than one channel — common pattern is Slack for the on-call channel + SMS for the primary responder.
- 8
Save and watch the first check come in
Click Save. The monitor appears in the Monitors list with status "Waiting…" until the first check completes — usually within one interval cycle (60s by default). Click the monitor name to open its detail page with live logs, uptime history and the incident timeline.
WhereSave (bottom-right) → Monitors list → click the monitor row - 9
Run a Test alert (recommended)
On the monitor detail page, click the "Test alert" button to fire a synthetic alert through every attached channel. This confirms your Slack webhook, email or SMS configuration works before a real outage depends on it.
WhereMonitor detail → Test alert (top-right)
Configuration Options
Every option you can set, what each choice means, and what to pick. Use this as a reference while you fill in the form.
Check type
AppStatus supports four check types. Pick the simplest one that proves your service is healthy.
| Field | Options | What it does | Recommended |
|---|---|---|---|
| HTTPS / HTTP | GET / POST / HEAD / PUT / DELETE | Sends an HTTP request and checks the status code and (optionally) the response body. | HTTPS GET against a /health or /status endpoint. |
| TCP (Port) | Host + port (e.g. db.example.com:5432) | Confirms the port accepts a TCP connection. Used for databases, message queues, custom services. | For non-HTTP services like Postgres, Redis, SMTP. |
| Ping | Host or IP | Checks the host is reachable. Cheapest signal — does not prove your app is healthy, only that the box is on. | For low-level network connectivity checks only. |
| API | Same as HTTPS plus stricter body validation | Same engine as HTTPS but optimised for JSON APIs — you can require a header, a JSON token, or a substring in the body. | For internal/external JSON APIs where response shape matters. |
Timing options
| Field | Options | What it does | Recommended |
|---|---|---|---|
| Check interval | 30s / 60s / 5m / 15m / 30m / 1h | How often the monitor runs. Smaller = faster detection, more plan quota used. | 60s for production; 5–15m for lower-priority services. |
| Timeout | 5s – 60s | How long to wait for the target to respond before counting the check as failed. | 30s (the default) for most APIs; raise it for slow batch endpoints. |
Validation options
| Field | Options | What it does | Recommended |
|---|---|---|---|
| Expected status code | Any 2xx (default) / specific code (e.g. 200) / range (200-299) | Only the configured code(s) are treated as UP — anything else is a failure. | Any 2xx unless you specifically want to enforce 200 only. |
| Expected response contains | Free text (e.g. "ok", "healthy") | A token that must appear in the response body. Useful when servers return 200 even on partial failure. | A short, stable keyword from your health endpoint payload. |
| Follow redirects | On / Off | When On, 3xx is followed before the check decides UP or DOWN. When Off, a 3xx counts as failure. | On for public pages; Off for API endpoints that should never redirect. |
| Verify SSL | On / Off | Fail the check if the TLS certificate is invalid, self-signed or expired. | On for all production HTTPS endpoints. |
| SSL alert days before expiry | 7 / 14 / 30 / 60 | How many days before the certificate expires AppStatus should start alerting. | 30 days — gives plenty of room to rotate. |
Feature Reference
Every feature, where to find it in the app, and what it does. Use this when you know what you want to do but not where it lives.
| Feature | Where in app | Description |
|---|---|---|
| Create / edit monitor | Sidebar → Monitors → Create new check | Add or update an uptime check with target, regions, validation and alerting rules. |
| Pause monitor | Monitor row → ⋮ menu → Pause | Temporarily stop checks during maintenance windows; uptime history is preserved. |
| Resume monitor | Monitor row → ⋮ menu → Resume | Re-enable a paused monitor; uptime calculation continues from where it left off. |
| Live logs | Monitor detail → Logs tab | Per-check results from the last 24h with status, latency, region and any error message. |
| Uptime history | Monitor detail → Uptime tab | Daily uptime % over 7 / 30 / 90 days for SLA reporting; exportable as CSV. |
| Incident timeline | Monitor detail → Incidents tab | Every incident this monitor opened with duration, root cause and resolution notes. |
| Test alert | Monitor detail → Test alert (top-right) | Sends a synthetic alert through every attached channel — confirms delivery before a real outage. |
| SSL certificate tracking | Monitor edit → Validation → Verify SSL = On | Tracks certificate expiry; alerts begin N days before expiry on every attached channel. |
| Multi-region consensus | Automatic — when you select 2+ regions | A single region failure becomes a soft warning; only multi-region agreement opens an incident. |
| Diagnostics replay | Monitor detail → Logs → click any failure row | Shows DNS resolve time, TCP connect, TLS handshake and time-to-first-byte for that exact check. |
Next Steps
Continue building your monitoring stack:
Configure Alerts
Build notification channels and escalation policies for monitor events.
Set up Status Pages
Publish monitor health to stakeholders with real-time status pages.
Manage Incidents
Track downtime events with lifecycle management and AI analysis.
Install the Agent
Add host-level telemetry alongside endpoint monitoring.
Set up Heartbeats
Monitor scheduled jobs and detect missed executions.
Team Governance
Control who can create, edit, and delete monitors.
