# isup.tools

> isup.tools checks whether a website is up or down right now, and says where the check ran from. Free, no key, no sign-up. Use it to answer "is it down, or is it just you?"

isup.tools makes one request to the site from the server that handled your request, and reports what came back: a verdict sentence, a status, the HTTP code, the time taken, and the real place the check ran from. It never reads or shows the site's content.

## Check a site over HTTP

- `GET https://isup.tools/check/{host}[/path][?query]` runs a check. Add `?format=md` or send `Accept: text/markdown` to get markdown. Without either you get an HTML page. Only `format=md` is read by isup.tools; every other query part, including any other `format` value, is sent to the site as typed.
- `GET https://isup.tools/check?url={host-or-url}` redirects (302) to the path form without running a check. A typed http:// or https:// is kept in the path; `format=md` is kept.
- `{host}` can be a bare domain (`example.com`), a full URL (`https://isup.tools/check/https://example.com/status`), or a host with a port (`example.com:8443`).
- `HEAD` works wherever `GET` does: the same status and headers, with no body. A `HEAD` to /check runs the check, so it counts toward the rate limit.
- Errors (HTTP 400, 404, 405, 429) come back as short markdown when you asked for markdown.

Example:

```
curl -H 'Accept: text/markdown' https://isup.tools/check/example.com
curl 'https://isup.tools/check/example.com?format=md'
```

Example output (illustrative values):

```markdown
# It's just you. example.com is up.

| Field | Value |
| --- | --- |
| Target | https://example.com/ |
| Status | UP |
| HTTP code | 200 |
| Latency | 84 ms |
| Checked from | (the city the check ran from) |
| Checked at | 2026-01-01T12:00:00.000Z |
| Reason | Site answered with HTTP 200. |

Result page: https://isup.tools/check/example.com (opening it runs a new check)
```

The first line is always the verdict sentence. The table follows. The last line links the HTML page for the same target.

## Verdicts

{host} is the host of the last URL checked, after any redirects.

| First line | Status | HTTP code | Meaning |
| --- | --- | --- | --- |
| It's just you. {host} is up. | UP | below 400 | The site answered normally. |
| It's not just you. {host} is down. | DOWN | 400 or higher, except 401, 403 and 429 | The site answered with an error. |
| {host} is answering with a redirect. | UP | 3xx | Redirects are followed up to 5 hops. This means the chain did not end: a loop, more than 5 hops, or a redirect without a usable address. |
| {host} can't be checked from the edge. | NOT CHECKABLE | none, or 401, 403, 429 | With no code: isup.tools cannot reach this port, or the site redirected to a private address; this says nothing about whether the site is up. With 401, 403 or 429: the site's server answered, so it is running, but it needs a sign-in (401), refuses automated checks (403) or is limiting requests (429), so isup.tools cannot tell whether the site works for people. |
| {host} could not be reached. | DOWN | none | No HTTP answer from the site: the connection failed, a server name for the site did not resolve, or there was no answer in time. |

Status is always one of: UP, DOWN, NOT CHECKABLE.

Table fields: Target (last URL checked), Status, HTTP code ("none" when there was no answer), Latency (ms, the whole check; "not measured" when no request was sent, as for an unsupported port), Checked from, Checked at (ISO 8601, UTC), Reason (one line, when there is one), Redirects (only when the check got redirects: each URL with the code it answered, joined by " → ", then the final URL; a redirect isup.tools refused to follow ends with "(not followed)"). New fields are only ever added at the end of the table.

## What isup.tools is not

- Not a monitor: it has no uptime history and sends no alerts. Each check runs once, when someone asks.
- Not crowd reports: it does not count user complaints. It makes one request and reports what came back.
- One place per check: the result shows what the site did from one location at one moment. A site can be up from one place and down from another.

## Citing a result

Start with the verdict sentence, then say where and when the check ran, for example: "isup.tools checked example.com from Singapore at 12:00 UTC: up, HTTP 200." Link the result page so the reader can run the same check again. A result is only true for the moment it was checked; to answer "is it down now?", run a new check instead of quoting an old one.

Pages under /check are live checks, so they send `X-Robots-Tag: noindex` and robots.txt asks crawlers to skip them. Fetch them when a person asks about a site.

## Where the check runs

The check runs on the server that receives the request, usually the one nearest the caller. For MCP, the caller is the machine running the MCP client, which may not be near the end user: for hosted clients it is the vendor's servers.

"Checked from" is always the real place: the city when known, the raw location code when the city is not known, or "Location unavailable" when there is no location data. Locations are never guessed.

## MCP server

- Endpoint: https://isup.tools/mcp
- Transport: Streamable HTTP. POST one JSON-RPC message per request; answers are JSON. No auth, no sessions. A body over 64 KiB gets HTTP 413 with a JSON-RPC error (-32600).
- Protocol versions: 2026-07-28 (per-request metadata, server/discover), and 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05 (initialize handshake).
- Tool: `check_site`. Input: `{"url": "example.com"}` (a domain or full URL).
- Result: the markdown above as text (verdict sentence first), plus `structuredContent` with verdict, target, status, httpCode, latencyMs (null when no request was sent), checkedFrom, checkedAt, reason, resultUrl (a page that runs the same check again), redirects (every redirect answer in order as {url, httpCode}; an empty array when there were none), finalUrl (the last URL requested, or null when no request was sent). URLs in redirects and finalUrl are cut at 300 characters.
- A refused address, a missing url or the rate limit comes back as a tool result with `isError: true` and a reason.

### Connect a client

Setup steps for every client, including menu-based ones (Claude on the web and desktop, ChatGPT, VS Code, Windsurf, Zed), one-click install links for Cursor and VS Code, and a snippet that tells a coding agent when to call the tool: https://isup.tools/mcp/setup

Claude Code:

```
claude mcp add --transport http isup https://isup.tools/mcp
```

Gemini CLI (use the command: its docs read a plain `url` in the settings file as SSE, which this server does not serve):

```
gemini mcp add --transport http isup https://isup.tools/mcp
```

Codex (`~/.codex/config.toml`):

```toml
[mcp_servers.isup]
url = "https://isup.tools/mcp"
```

Cursor (`.cursor/mcp.json` or `~/.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "isup": { "url": "https://isup.tools/mcp" }
  }
}
```

Clients with an `mcpServers` JSON config that takes a `type` (Claude Code's `.mcp.json`, VS Code with GitHub Copilot):

```json
{
  "mcpServers": {
    "isup": { "type": "http", "url": "https://isup.tools/mcp" }
  }
}
```

Cline needs `"type": "streamableHttp"` instead. There is no SSE transport here, so a client that falls back to SSE when no type is given cannot connect.

Hosted clients (Claude on the web, desktop and mobile; ChatGPT; the OpenAI and Anthropic APIs) connect from the vendor's servers. For them "Checked from" is a place near the vendor's servers, not near the person, and all their users share one rate-limit allowance for each vendor address.

## Limits and rules

- Rate limit: about 6 checks per minute per IP address (for IPv6, per /64 network). The limit is loose: the count is kept per server location and catches up slowly, so a quick burst can get many more checks through before a 429. Do not rely on an exact number. Over the limit: HTTP 429 with Retry-After, or an `isError` result over MCP. Only checks count; a refused address, the ?url= redirect, this file and other MCP requests do not. Hosted MCP clients call from the vendor's addresses, so their users share one allowance.
- Time: one 10-second budget covers the whole check: the first try, the single http retry, and up to 5 redirect hops.
- Ports: only 80, 443, 8080, 8443, 2052, 2053, 2082, 2083, 2086, 2087, 2095, 2096, 8880. Any other port gets NOT CHECKABLE, never DOWN.
- https first: a bare domain is tried over https. If that connection fails (not a time-out), http is tried once and Target shows the http URL. When that http answer is the final answer, the reason starts with "HTTPS failed; HTTP used."; when it is a redirect, the redirect is followed and the reason says so. A scheme you type is kept and never retried.
- Refused addresses (HTTP 400, nothing is fetched): schemes other than http and https; addresses with a user name or password; localhost, *.localhost and *.internal (also with a trailing dot); private IP addresses (10/8, 172.16/12, 192.168/16, 127/8, 169.254/16, 0/8, ::, ::1, fc00::/7 and IPv4-mapped forms). Every redirect hop is checked the same way; a redirect to a refused address ends the check as NOT CHECKABLE.
- Only the status code and timing are used. The response body is never read.
- Each request to the site sends `User-Agent: isup/0.1.0 (+https://isup.tools/)` and no other browser-like header.
- Results are never cached (Cache-Control: no-store). Every request runs a new check.

## Links

- [Live check of example.com, markdown](https://isup.tools/check/example.com?format=md)
- [MCP endpoint](https://isup.tools/mcp): POST JSON-RPC here.
- [MCP setup guide](https://isup.tools/mcp/setup): steps for each client.
- [Home page](https://isup.tools/): the HTML form. Ask for markdown to get this text.
