How Apitally Handles API Alerts and Uptime Monitoring

Updated

Apitally covers three distinct alerting mechanisms: custom threshold alerts across 14 traffic, error, and performance metrics; uptime checks that fire when your application stops sending heartbeats; and health checks that send synthetic HTTP GET requests to an endpoint you specify. Together they address downtime, traffic spikes, errors, and performance problems. All three are part of the monitoring and alerts feature set, and request logging — a separate capability — is optional and works independently of analytics and monitoring.

Custom alerts: threshold-based notifications

Apitally lets you configure thresholds for 14 different traffic, error, and performance metrics, and notifies you when a threshold is breached. The metric categories map to the dashboard views described on the site:

Category What it tracks
Traffic Request volume over time, per endpoint and per consumer
Errors Client and server errors, their impact, and root cause
Performance Response times of your endpoints, to identify bottlenecks
Consumers Adoption and how individual consumers use your API

The practical value of threshold alerts is catching a problem before it reaches consumers. For example, if you set a threshold on server error rate for a specific endpoint, you get notified when that endpoint starts failing rather than hearing about it from a customer. Because thresholds are configurable per metric, you decide which signals matter enough to interrupt you.

Uptime checks: heartbeat-based

Uptime checks work on a heartbeat model. Your application sends regular heartbeats to Apitally's servers, and you get notified when it stops sending them. This detects the case where your application itself has gone down or lost the ability to report — a failure mode that threshold alerts alone can miss, since a dead application produces no metrics to breach a threshold.

Health checks: synthetic HTTP requests

Health checks monitor your API's availability by sending synthetic HTTP GET requests to a specified endpoint at regular intervals. This is an external, black-box view of availability: it tests whether the endpoint actually responds, independent of whether your application is successfully reporting telemetry.

The distinction matters when choosing between them:

  • Uptime checks tell you your application stopped reporting — useful when the reporting path and the application share fate.
  • Health checks tell you a specific endpoint is unreachable or unhealthy from the outside — useful when you want to verify real availability rather than infer it from telemetry.

Using both gives you coverage of internal reporting failure and external reachability failure.

What this means in practice

If your goal is "know about API problems the moment they happen," the three mechanisms divide the work:

  1. Something is slow or erroring → custom threshold alerts on performance and error metrics.
  2. Your app went silent → uptime check heartbeat notification.
  3. An endpoint is unreachable → health check synthetic GET requests.

Setup is described as minimal: a few lines of code, no infrastructure changes, and no performance impact. A 14-day free trial is available, and you can explore with demo data without any setup.