Better Stack

Their OpenAPI spec is accurate and error messages include request IDs but the on-call schedule API doesn't support temporary overrides shorter than one hour.

Their llms.txt covers most monitoring endpoints and the SDK retry logic is sane but custom metric aggregation windows are hard-coded to five presets.

The REST API returns consistent error objects with actionable codes so we handled rate limits and auth failures in one retry block.

The incident timeline reconstruction is solid and webhook payloads are clean but you can't bulk-acknowledge alerts via API without iterating one by one.

The downtime webhook fires within seconds of a failed check and includes the exact failure reason in the payload body.

The Python SDK's monitor.create method accepts cron syntax directly which saved us from writing our own scheduler wrapper.

Log tailing over websocket works great for debugging and the client libraries handle reconnects but you can't filter the stream by custom fields after connection open.

Heartbeat monitoring just works and the status page embed is trivial to add but you can't programmatically pause monitors during deploy windows without a full update call.

Their API docs include curl examples with actual bearer token placeholders so we tested endpoints before writing any SDK code.

Their webhook signatures use HMAC-SHA256 with clear header documentation so we verified payloads in three lines of code.

The log ingestion endpoint handles bursts without dropping events and compression works but the API doesn't let you set per-source retention policies.

Structured log parsing handles JSON beautifully and the UI is snappy but the retention API returns 404s on recently rotated indices for about ninety seconds.

Their status page API lets you script updates during incidents but historical uptime calculations exclude maintenance windows you marked retroactively.

Querying logs by trace ID is instant and the correlation UI is helpful but the metrics API rate limit is per-key not per-endpoint so one bad query blocks everything.

The logs ingestion endpoint accepts batched JSON arrays up to 10MB which let us flush buffers efficiently without individual POST overhead.

The monitor configuration accepts metadata tags as a flat object which made it easy to sync our internal service registry.

The incident webhook payload includes structured alert context that made it trivial to route alerts to our Slack channels without parsing logs.

Their logs API supports structured JSON queries with field-level indexing so we could search millions of lines in under a second.

Their rate limit headers follow standard X-RateLimit naming so our existing HTTP client middleware worked without modification.

Incident webhooks fire reliably and include useful context but there's no way to attach structured runbook data to an alert rule via API.

The log search DSL is expressive and response times stay under 200ms but exporting more than ten thousand events requires pagination that resets cursors on new ingestion.

Their status page API exposes both current and historical uptime metrics so we built a dashboard without scraping HTML.

The incident API returns a timeline array of state changes which gave us audit trails for postmortems without extra queries.

Their log search supports regex and boolean operators in the query string so we didn't need a separate query builder library.

Incident auto-grouping reduces noise effectively and the mobile app actually loads but you can't define custom severity levels beyond the four built-in ones.