---
title: "Rate limits"
description: "Every limit the Monitive API enforces, the response you get when you hit one, and which headers to read."
doc_version: "1"
last_updated: "2026-11-19"
---

The API allows 200 requests per minute per account, and some endpoints add tighter limits on top. Going over a rate limit usually returns `429 Too Many Requests` with a `Retry-After` header: wait that many seconds, then retry. Some limits instead return another status, suppress a background delivery, replace an existing resource, or return an MCP tool error. Each section documents its exception; see [Handling 429 responses](#handling-429-responses). Rate limits never suspend your account.

## API requests per account

Your account can make 200 requests per minute. The limit is a token bucket: a full allowance lets you send up to 200 requests at once, and it refills continuously at 200 per minute.

Every API key, dashboard session, and OAuth token on the account shares one allowance. The limit is not per key.

Most requests to registered authenticated `/api/v1` routes spend one request after authentication and the route's role or admin check. Session-capable routes, including `/api/v1/me`, spend one after authentication but before any route-specific session check. Authenticated `/mcp` requests spend one before any tool-specific role check. A request refused with `401`, or with `403` by an ordinary REST role or admin check, doesn't normally spend the allowance.

One exception applies to successfully authenticated API keys while their bounded cache entry remains. A later request that enters a registered, Bearer-authenticated `/api/v1` route or mounted subtree is charged before authentication and authorization. A cache entry expires five minutes after the key's last successful authentication, but it can be evicted earlier. Therefore, a later `401` or `403` can still spend one request. If the allowance is exhausted, the request gets `429` before authentication. An unmatched path isn't precharged. `GET /api/v1/events/stream` and `GET /api/v1/admin/events/stream` are not charged.

Webhook deliveries don't count against your allowance, because Monitive sends them.

## Per-endpoint limits

Most of these limits apply on top of the account allowance, so a request must fit inside both. The exceptions are `GET /api/v1/events/stream` and `GET /api/v1/admin/events/stream`: they don't spend the account allowance, so only their own stream caps apply.

- **`POST /api/v1/monitors`**: 20 per minute per account, on top of the 200. Going over it returns `429` with `Retry-After` and `monitor creation rate limit exceeded; retry in <N>s`.
- **`POST /api/v1/monitors/{id}/test`**: 1 every 10 seconds per monitor. Going over it returns `429` with `Retry-After` and `too many tests for this monitor; retry in <N>s`.
- **`POST /api/v1/monitors/{id}/test`**: 600 checks per minute against one registrable domain, across all accounts. The limit is counted per domain. Going over it returns `429` with `Retry-After` and `domain rate limit exceeded; retry in <N>s`.
- **`POST /api/v1/events/ticket`**: 20 per minute per credential: the API key, or the user for a session or OAuth token. Going over it returns `429` with `Retry-After` and `ticket rate limit exceeded`.
- **`GET /api/v1/events/stream`** and **`GET /mcp`**: 10 open streams at once per credential, shared between the two. A refusal returns `429` with `max concurrent stream connections reached (10); REST event streams and MCP streams share this limit per API key` and no `Retry-After`.
- **`POST /api/v1/admin/events/ticket`** (Monitive admin users only): 10 per minute per admin user. Going over it returns `429` with `Retry-After` and `ticket rate limit exceeded`.
- **`GET /api/v1/admin/events/stream`** (Monitive admin users only): 5 open streams at once per admin user. A refusal returns `429` with `max concurrent connections reached` and no `Retry-After`.
- **`POST /api/v1/recipients/{id}/test`**: 1 per minute per recipient. Going over it returns `429` with `Retry-After` and `too many test requests for this recipient; retry later`.
- **`POST /api/v1/recipients`** for an email recipient, **`PATCH /api/v1/recipients/{id}`** that changes the address, and **`POST /api/v1/recipients/{id}/confirm/resend`**: Confirmation emails are limited to 5 per hour per address, 20 per hour per account, and 300 per hour in one API process. The limits are counted per address, account, and API process. Going over a limit returns `429` with `Retry-After` and `too many confirmation emails; retry later` on create and patch, or `too many confirmation resends; retry later` on resend.
- **`POST /api/v1/recipients/{id}/confirm/resend`**: 1 every 60 seconds per recipient, counted from the last confirmation email to that recipient and separate from the hourly quotas above. Going over it returns `429` with `Retry-After` and `resend requested too recently`.

When Google or Microsoft sign-up creates a pending default email recipient, its confirmation attempt shares the same address, account, and API-process quotas. If any quota is exhausted, sign-up continues without a `429`, Monitive suppresses the confirmation email, and the recipient stays pending.

Over MCP, `create_monitor` shares the 20-per-minute monitor-creation limit. Going over it returns a tool error with the same message, `monitor creation rate limit exceeded; retry in <N>s`, not an HTTP `429`. That error has no `Retry-After` header; the message carries the wait.

A new monitor whose first check is held back by the per-domain cap shows `"last_check_skipped": "domain_rate_limited"`.

## New-domain limits

Two rolling allowances limit how many distinct registrable domains your account can target. A successful monitor creation counts its target. A monitor update counts only if it changes the monitor's `url` or `type`; updates to other fields don't count.

Monitive lowercases each host, removes trailing root dots, and uses the public suffix list to find its effective top-level domain plus one. For example, `api.example.com` and `status.example.com` both count as `example.com`. If that lookup fails for an IP address, a single-label host, or an unrecognized suffix, the normalized full host is the domain key.

Both allowances are inclusive. The 30-minute allowance normally follows your plan's monitor cap, but an account can have a custom domain allowance. The 24-hour allowance always follows the plan's monitor cap. See [Pricing](/pricing/) for plan limits.

| Window | Allowance |
|---|---|
| Rolling 30 minutes | The same as your plan's monitor cap, unless your account has a custom domain allowance |
| Rolling 24 hours | Twice your plan's monitor cap |

Over REST, going over either allowance returns `429 Too Many Requests`. The rate-limit headers have the following values, where `<L>` is the controlling allowance, `<W>` is `1800` or `86400`, and `<N>` is the number of seconds to wait:

```
Retry-After: <N>
X-RateLimit-Reason: host_fan
X-RateLimit-Window: <W>
X-RateLimit-Limit: <L>
```

The response omits `X-RateLimit-Remaining` and `X-RateLimit-Reset`. Its body is:

```
{"error":"too many distinct domains in a rolling window; slow monitor creation or target changes and retry","limit":<L>,"window_seconds":<W>,"retry_after_seconds":<N>}
```

Your account is not suspended. Wait for `Retry-After`, then retry.

Over MCP, `create_monitor` and target-changing `update_monitor` calls return a tool error instead of an HTTP `429`. The exact message is `too many distinct domains in a rolling window; slow monitor creation or target changes and retry in <N> seconds (limit: <L> domains per <W>s)`. A tool error has no HTTP rate-limit headers.

## Public endpoints

These limits are counted per token, email address, or IP address, never per account. Every refusal is a `429` with `Retry-After`.

- **`GET /feed/{token}`** and **`GET /feed/{token}/rss`**: 20 per minute per feed token. Every request counts. A refusal returns `too many requests; retry in <N>s`.
- **`GET /ack/{token}`**: 60 per hour per IP address, separate from `POST /ack/{token}`. Every request counts. A refusal returns `too many requests; retry later`.
- **`POST /ack/{token}`**: 60 per hour per IP address, separate from `GET /ack/{token}`. Every request counts. A refusal returns `too many requests; retry later`.
- **`POST /oauth/email/start`**: 5 per hour per email address, 20 per hour per IP address, and 300 per hour across all callers. Every request counts. A refusal returns `too many sign-in requests; retry later`.
- **`POST /oauth/email/verify`**: 30 per hour per IP address and 600 per hour across all callers. Every request counts. A refusal returns `too many sign-in attempts from this address; retry later` per IP or `too many sign-in attempts; retry later` across all callers.
- **`GET`** and **`POST /email/confirm/{token}`**: 60 per hour per IP address, one allowance shared by `GET` and `POST`. Every request counts. A refusal returns `too many requests; retry later`.
- **`GET /email/unsubscribe/{token}`**: 60 per hour per IP address, with its own allowance. Every request counts. A refusal returns `too many requests; retry later`.
- **`GET /email/reports/{type}/unsubscribe/{token}`**: 60 per hour per IP address, with its own allowance. Every request counts. A refusal returns `too many requests; retry later`.
- **`POST /email/unsubscribe/{token}`**: 60 per hour per IP address and 300 per hour across all callers. Only malformed or unknown tokens count; a valid unsubscribe never counts. Once either allowance runs out, every unsubscribe `POST` from that IP address, or from anyone for the allowance across all callers, is refused until it refills. A refusal returns `too many requests; retry later`.
- **`POST /email/reports/{type}/unsubscribe/{token}`**: 60 per hour per IP address and 300 per hour across all callers, separate from the recipient-unsubscribe allowances. Only an unknown report type, or a malformed or unknown token, counts; the same refusal rule as the preceding bullet applies. A refusal returns `too many requests; retry later`.
- **`POST /oauth2/register`**: 10 per hour per IP address and 100 per hour across all callers. Every request counts. A refusal returns `too many client registrations from this address; retry later` per IP or `too many client registrations; retry later` across all callers, in the RFC 7591 body shape.

Linking an email sign-in from the dashboard, through `POST /api/v1/me/identities/email/start` and `POST /api/v1/me/identities/email/verify`, uses the same sign-in limits.

## Count limits

These caps limit how many of something an account or account member holds. The non-GET-monitor and API-key caps return `409 Conflict` over REST, not `429`. Waiting doesn't clear them; you have to remove one first. The browser push-subscription cap returns no error: a new subscription replaces that account member's oldest one.

| What | Cap | REST response | MCP response |
|---|---|---|---|
| Monitors with a non-GET `http_method`, disabled ones included | 5 per account | `409` with `non-GET monitor limit reached (max 5 per account)` | `create_monitor` and `update_monitor` return a tool error with the same text |
| API keys | 10 per account | `409` with `key limit reached`, on create and on rotate | `rotate_api_key` returns a tool error, `key limit reached` |
| Browser push subscriptions | 20 per account member | No error. A new subscription replaces that account member's oldest one. | None; there is no MCP tool |

Your plan's monitor count is listed on [Pricing](/pricing/).

Browser push delivery has a separate limit of one push fan-out per monitor in each five-minute window. After Monitive starts a fan-out, it suppresses browser-push fan-outs for later state transitions on that monitor during the rest of the window. This asynchronous suppression has no HTTP response and doesn't fail an API request.

## Alert email cap

By default, Monitive sends at most 1,000 alert emails per account per UTC day. All of the account's email recipients share the count.

An alert email over the cap isn't sent. Its row in `GET /api/v1/webhook-deliveries` has `status` set to `failed`, `last_response_code` set to `0`, and `response_body` set to `daily email cap reached`. No API request fails because of this cap.

## Response headers

Except for a new-domain `429`, responses to requests charged by the account allowance carry three `X-RateLimit-*` headers, on successes and on its `429`s alike. This includes authenticated `/mcp` requests, most `/api/v1` requests after authentication and authorization, and session-capable `/api/v1` routes that are charged before their route-specific session check. It also includes a cached API key's `401` or `403` response when the request was precharged.

```
X-RateLimit-Limit: 200
X-RateLimit-Remaining: 187
X-RateLimit-Reset: 1681310460
```

| Header | Meaning |
|---|---|
| `X-RateLimit-Limit` | The allowance size, `200`. |
| `X-RateLimit-Remaining` | Requests left after this one. |
| `X-RateLimit-Reset` | The Unix time, in seconds, when the allowance is **full** again. It is not when your next request is allowed. |

A successful `POST /api/v1/monitors` carries the 200 allowance. A `429` from the monitor-creation limit replaces all three values with that limit's own, so `X-RateLimit-Limit` reads `20`. Concurrent-stream refusals on `GET /mcp` don't change the three headers.

A new-domain `429` doesn't carry the trio. It sets `X-RateLimit-Limit` to the controlling domain allowance, adds `X-RateLimit-Reason: host_fan` and `X-RateLimit-Window`, and removes `X-RateLimit-Remaining` and `X-RateLimit-Reset`.

These responses never reach the account allowance and don't carry the `X-RateLimit-*` headers: `GET /api/v1/events/stream`, `GET /api/v1/admin/events/stream`, and every public endpoint under `/feed/*`, `/oauth/*`, `/oauth2/*`, `/email/*`, and `/ack/*`. Don't infer header behavior from a `401` or `403` status alone. A `401` or `403` carries the headers if the request was already charged, such as when a cached API key is precharged or a session-capable route is charged before its session check. Otherwise, the headers are absent.

`Retry-After` is a separate header. It is sent on a `429` only, as whole seconds to wait. It appears on every `429` on this page, authenticated or public, including the endpoints that never carry the `X-RateLimit-*` headers. It does not appear on the concurrent-stream refusals: `GET /api/v1/events/stream`, `GET /mcp`, and `GET /api/v1/admin/events/stream`. On a `429`, use `Retry-After`, not `X-RateLimit-Reset`.

## Handling 429 responses

Wait `Retry-After` seconds, then retry. The value is a whole number, at least `1`. On `POST /api/v1/monitors/{id}/test` and `/feed/{token}`, the value is rounded down, so add a second.

Treat every `429` as temporary. On an HTTP `429`, read the delay from `Retry-After`, not from the message.

Apart from the new-domain limits, `429`s on `/api/v1/*`, `/feed/*`, `/oauth/email/*`, `/email/*`, and `/ack/*` use the flat error envelope:

```json
{"error": "account rate limit exceeded; retry in 12s"}
```

```
Retry-After: 12
```

`/mcp` returns a JSON-RPC error:

```json
{"jsonrpc":"2.0","id":null,"error":{"code":-32000,"message":"account rate limit exceeded; retry in 12s"}}
```

`/oauth2/register` uses the RFC 7591 shape:

```json
{"error":"too_many_requests","error_description":"too many client registrations from this address; retry later"}
```

Four cases work differently:

- **New-domain limits.** A REST `429` from the new-domain limits can carry more fields than `error`. Don't parse the body for the wait; use `Retry-After`.
- **Concurrent-stream caps.** `GET /api/v1/events/stream`, `GET /mcp`, and `GET /api/v1/admin/events/stream` return `429` with no `Retry-After`. Close one of your streams, or wait for one to end, before you open another. The ticket isn't spent, so you can retry with it.
- **MCP tool errors.** Over MCP, the monitor-creation limit, the new-domain limits, the non-GET-monitor cap, and the API-key cap come back as a tool error inside a successful HTTP response, not as an HTTP `429` or `409`. A tool error has no headers. For the monitor-creation limit, the message says how many seconds to wait.
- **Count limits.** The non-GET-monitor and API-key caps return `409`, not `429`. Waiting doesn't help; remove one first. The browser push-subscription cap returns no error; the oldest subscription is replaced.

For the error envelope and other status codes, see [Errors](/docs/errors/#429-too-many-requests).

## What suspends an account

No rate limit or count limit suspends your account, and repeated `429`s don't make the wait longer.

Two security checks do suspend an account:

- **Port scanning.** Creating monitors, or changing a monitor's `url` or `type`, so that 6 or more distinct ports on at most 2 hosts are targeted within 10 minutes. Ports used by TCP monitors count against a higher threshold of 12. The account is suspended and its monitors are removed.
- **DNS rebinding.** A monitored hostname that later resolves to a blocked address. The re-check that runs every 5 minutes catches it.

A suspended account gets `403` with `account suspended; contact support` on authenticated requests.