---
title: "Status page"
description: "Turn on a monitor's free public status page from the dashboard or the API."
doc_version: "1"
last_updated: "2026-11-19"
---

## What it does

Turning on a monitor's status page publishes one read-only page at `https://status.monitive.com/sp_…`, a public URL that needs no login. The page shows:

- The current status (up, down, flapping, paused, or unknown), when the monitor was last checked, and, while it's down, how long it has been down.
- A 30-day grid of daily uptime percentages. It uses the same calculation as `GET /api/v1/monitors/{id}/uptime`, served from a cached snapshot that can run up to about 70 seconds behind (see [Plan limits](#plan-limits)). A day before the monitor existed reads "Not monitored yet," never a made-up percentage.
- The 30-day average uptime and response time, and a downtime history.

![A public status page: the monitor's name and host, an Up headline with the last check time, tiles for 30-day uptime, downtime, and average response time, and a 30-day grid of daily uptime bars with one day's outage details in a tooltip](/_astro/free-status-page-2-public-page.Dv-rGfit.png)

The same page has RSS, Atom, and JSON siblings at `/feed.rss`, `/feed.atom`, and `/status.json` under the same token, plus an SVG badge at `/badge.svg`. To show that badge in a README or on your own site, see [Uptime badge](/docs/guides/uptime-badge/).

The page carries no authentication, and search engines can index it. The unguessable token in the URL is the only thing keeping it unlisted; it isn't a lock. Read the caution in [Set it up in the app](#set-it-up-in-the-app) before you publish one.

Pausing the monitor doesn't unpublish the page. It keeps serving, with a paused headline. To revoke the URL, turn the status page off.

## Set it up in the app

:::caution
This page has no login, and search engines can index it. It publishes the monitor's name, its host, its current status and check times, the last 30 days of daily uptime, the 30-day averages, and up to 50 incident lines. It does **not** publish the monitor URL's path or query string, request headers, or the request body. Anyone you share the page URL with, and anyone who sees an embedded [uptime badge](/docs/guides/uptime-badge/), can reach the page.
:::

1. Open the monitor's detail page and find the **Status page** section.
2. Turn on the **Public status page** switch. Its label changes from **Private** to **Public**.
3. Copy the URL with the copy button, or click **Open** to view the page.

![The monitor detail page's Status page section, with the Public status page switch turned on and the page URL next to the copy and Open controls](/_astro/free-status-page-1-switch.Bk6ZzT3T.png)

Turning the switch off opens a **Turn off the status page?** confirmation. It explains that the old URL can stay reachable for about 70 seconds while an already-admitted build finishes and caches expire, and that turning the page back on mints a different URL.

## Do the same through the API or MCP

Turn the page on:

```bash
curl -X PUT https://api.monitive.com/api/v1/monitors/1287/status-page \
  -H "Authorization: Bearer $MONITIVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true}'
```

```json
{"enabled": true, "url": "https://status.monitive.com/sp_0123456789abcdef0123456789abcdef"}
```

Read the switch state the same way, with no body:

```bash
curl https://api.monitive.com/api/v1/monitors/1287/status-page \
  -H "Authorization: Bearer $MONITIVE_API_KEY"
```

`url` is `null` when the page is off. Once you have the URL, from the dashboard's copy button or from this response's `url` field, assign it to a shell variable instead of pasting it straight into a command:

```bash
PAGE_URL='https://status.monitive.com/sp_0123456789abcdef0123456789abcdef'
```

Replace that value with your own page's URL. The public routes take no `Authorization` header:

```bash
curl "$PAGE_URL/status.json"
```

To build the badge URL and its embed snippets from the same page URL, see [Uptime badge](/docs/guides/uptime-badge/).

There's no MCP tool for this switch. Turn a status page on or off through the REST calls in this section or the dashboard. See [Monitors](/docs/monitors/) and [Feeds](/docs/feeds/) for the monitor and feed-token references this pairs with.

## Plan limits

- One status page per monitor. The free product doesn't offer multi-monitor or branded pages.
- The page, its feeds, and `status.json` cover a trailing 30-day window, the same window the uptime API uses.
- The downtime history and feeds project at most 50 entries, newest first. The 30-day uptime math still accounts for every incident that overlaps the window; only the projected list is capped.
- The origin caches a built page for 60 seconds once the live status agrees with the open incident rows, or 5 seconds while it doesn't. See [Troubleshooting](#troubleshooting) for what "doesn't agree" means in practice. A build can run up to 10 seconds before its result is cached, so the data behind any one response can be up to about 70 seconds old for a settled page, or about 15 seconds for an unsettled one.
- Turning the page off revokes the token at the origin for anything that asks afterward. A build already in flight when you flip the switch can still finish and get served, and the result can stay cached, so the old URL can keep answering for roughly that same 70 seconds.
- Turning the switch on or off requires the account owner role; reading the switch state only requires viewer.
- See [Monitors](/docs/monitors/) for the monitor count and other shared account limits.

## Troubleshooting

**The URL returns `404`.** The page is off, the monitor was deleted, the account is suspended, or the token is malformed. A paused monitor does not cause this: pausing leaves the page public with a paused status.

**`curl -I`, or any non-GET request, returns `404` even though the page loads in a browser.** The status host's routes are GET-only. `HEAD`, `POST`, `PUT`, and `DELETE` all get the same `404` by design, so a method probe can't distinguish "doesn't exist" from "wrong verb." Check with a GET instead:

```bash
PAGE_URL='https://status.monitive.com/sp_0123456789abcdef0123456789abcdef'
curl -s -o /dev/null -w '%{http_code}\n' "$PAGE_URL"
```

**`503` with a `Retry-After: 5` header.** A page build hit its time limit. Retry after the advertised delay. Don't turn the page off and back on to fix it: that mints a different URL and breaks every embedded badge.

**`500`.** A service failure, not a problem with your token. Retry later; there's nothing to rotate.

**The page is still public after I paused the monitor.** By design: pausing doesn't unpublish anything. Turn the status page off instead.

**The page shows up in search results.** Also by design: the free status page isn't marked `noindex`. Turning the status page off revokes the URL, and turning it back on mints a different one.

**The page still loads for a bit after I turned it off.** That's the cache tail described in [Plan limits](#plan-limits): up to about 70 seconds at the origin.

**The public page's numbers lag the dashboard or the uptime API.** They share the same calculation, but the public page serves a cached snapshot that can be up to about 70 seconds old for a settled page, or about 15 seconds while it's unsettled (see [Plan limits](#plan-limits)). A page stays unsettled for as long as its live status disagrees with the open incident rows, or while the status is still unknown, not only during a brief transition. The response's `Age` header counts from when that snapshot was cached, so it understates the data's real age by however long the build itself took.

**`400 enabled is required`, `400 enabled is the only allowed field`, `401`, `403`, or `415`.** The `PUT` body must be exactly `{"enabled": <bool>}`. A missing or non-boolean `enabled`, or any other key, is `400`. `401` means a missing or invalid `Authorization` header. `403` means the caller isn't the account owner. `415` means the request is missing `Content-Type: application/json`.

**The dashboard shows "URL unavailable."** The switch is on, but the API didn't return a usable URL. That points to a server-side configuration problem, not something you can fix from the dashboard.