canonical: https://jentic.com/apis/getuptimely.com/getuptimely

# Getuptimely Uptimely API

The Uptimely API creates uptime monitors, declares and tracks incidents, and drives public status pages for people and agents alike. It records each monitor's status history, sends alerts and moves them through states, and lets you save an incident postmortem once a situation is resolved. Webhook endpoints with rotatable signing secrets, on-call lookups, and per-project usage round out the monitoring surface.

## For AI agents

Create uptime monitors, read their status history, declare and update incidents, send alerts, and manage public status pages and webhook endpoints.

## Scope

Does not handle application performance tracing, log aggregation, or server provisioning. Use for uptime monitoring, incidents, alerts, and status pages only.

## Capabilities

- Create and update monitors, then read a monitor's status history over time
- Send alerts and change an alert's state as a situation evolves
- Declare incidents, change their state, and save a postmortem when resolved
- Build status pages and choose which monitors they show
- Mute and unmute a monitor's alerting during planned maintenance
- Register webhook endpoints and rotate their signing secret to receive delivery events

## Use cases

### Agent-Managed Uptime Monitoring

An AI agent stands up monitoring for a new service without a human clicking through a dashboard. It creates a monitor, reads the status history to confirm checks are running, and registers a webhook endpoint so downstream systems hear about state changes. Jentic exposes each Uptimely operation with its input schema so the agent sets the check interval and target correctly on the first call.

Example prompt: Create an HTTP monitor for a homepage URL, read its status history to confirm it is checking, and register a webhook endpoint for its state changes

### Incident Lifecycle Automation

An on-call workflow declares an incident the moment a monitor goes down and walks it through to resolution. The Uptimely API declares the incident, changes its state as responders work, and saves a postmortem once service is restored, while the current on-call lookup tells the agent who to notify. Alerts move through their own states alongside the incident.

Example prompt: Declare an incident for a failing monitor, look up who is on call now, then change the incident state as it is worked

### Public Status Page Updates

A team keeps customers informed by surfacing the right monitors on a public status page. The Uptimely API creates a status page, adds monitor resources to it, and removes them when a service is retired, so the page reflects what is actually watched. Monitors can be muted during planned maintenance so the page does not alarm needlessly.

Example prompt: Create a status page, show a monitor on it, then mute that monitor's alerting for a scheduled maintenance window

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v1/monitors` | List monitors |
| POST | `/v1/monitors` | Create a monitor |
| GET | `/v1/monitors/{monitor_id}/status-history` | Read a monitor's status history |
| POST | `/v1/incidents` | Declare an incident |
| POST | `/v1/incidents/{incident_id}/state-changes` | Change an incident's state |
| POST | `/v1/status-pages` | Create a status page |
| GET | `/v1/on-call/current` | Look up who is on call now |

## Key resources

- **Monitors** — Create, update, delete, mute, and export monitors and read their status history
- **Incidents** — Declare incidents, change their state, and save postmortems
- **Alerts** — Create alerts and change an alert's state
- **Status pages** — Create and update status pages and manage which monitors they show
- **Webhook endpoints** — Create and delete webhook endpoints, rotate signing secrets, and list recent deliveries
- **On-call and usage** — Look up who is on call now and read per-project API usage

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 81 / 100
- **Maturity:** AI-Ready
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 69 / 100
  - AI-Readiness & Agent Experience: 88 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 78 / 100
- **View full report:** https://jentic.com/apis/getuptimely.com/getuptimely/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Uptimely API by hand means managing its bearer token, learning the monitor, incident, and alert state models, and keeping webhook signing secrets in sync. Through Jentic you install once, import Uptimely from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Uptimely puts the monitor id and status-page id in the URL path (`/v1/monitors/{monitor_id}`, `/v1/status-pages/{status_page_id}`), so a rule can pin your agent to the monitors and status pages you name and the operations you pick. You choose the operations it may call, so deleting a monitor or a status page is not included unless you add them.
- **Credential handling:** Your Uptimely token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a monitor' or 'declare an incident', and Jentic returns the matching Uptimely operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **UptimeRobot** — UptimeRobot monitors endpoints and surfaces status pages with a long-established free tier.
- **StatusCake** — StatusCake runs uptime, page speed, and domain monitoring from global regions.
- **Statuspage** — Statuspage focuses on customer-facing incident communication.

## FAQ

### What authentication does the Uptimely API use?

The Uptimely API authenticates with a bearer token in the Authorization header, in the uptimely_live_ key format, per its OpenAPI spec. Through Jentic that token is stored encrypted by your own Jentic One instance and injected at call time, so it never sits in your agent's prompt or logs.

### Can I declare incidents with the Uptimely API?

Yes. You declare an incident, change its state through the state-changes operation as responders work, and save a postmortem once it is resolved. The current on-call lookup tells your agent who is responsible at the moment the incident opens.

### What are the rate limits for the Uptimely API?

The Uptimely OpenAPI spec does not publish fixed rate limits. The usage endpoint returns your current project usage, so your agent can read consumption before sending more requests rather than guessing a ceiling.

### Is there an Uptimely MCP server?

You do not need an MCP server to give your agent the Uptimely API. Jentic connects it directly from the API Directory: import it, store your token once, and your agent calls its operations. Operations are discovered on demand, so your agent's context stays lean instead of loading a full tool list up front.

### Can I limit what my agent is allowed to do with the Uptimely API?

Yes. Write a rule that allows only the monitor-read and incident operations, so the agent can watch monitors and declare or update incidents but cannot delete a monitor or change your status pages, and every call it makes is logged. Deletion stays out of the allowed set until you add it.

### How do I create a monitor with the Uptimely API through Jentic?

Search Jentic for 'create an uptime monitor', and it returns the Uptimely monitor-create operation with its input schema. Your agent posts the target URL and check interval, then reads the status history to confirm checks are running. To run it on your own infrastructure, install Jentic One from its GitHub repo.