HostTracker MCP server

Connect an AI assistant to HostTracker over the Model Context Protocol and let it operate your monitoring account in conversation: run a live check from 300+ global locations, see what is down, create or pause a monitor, schedule a maintenance window, review incidents, manage who gets alerted, wire a webhook, publish a status page update.

Endpoint   https://mcp.host-tracker.com/mcp
Transport  streamable HTTP
Auth       Authorization: Bearer <your HostTracker API token>

This repository is the public face of that hosted server: the connection metadata (server.json), the per-client setup guide (CLIENT.md), and the security policy (SECURITY.md) - and, since 2.0.0, the server's own source code in src/, so you can read exactly what runs behind the endpoint or run a copy yourself (see "Run it yourself" below).

Connect in two minutes

1. Mint a token. Go to Integrations -> API and create a token with the scopes you want the assistant to have (start with check and monitor:read).
2. Point your client at the endpoint with that token in an Authorization header. Configuration blocks for every common client are below.
3. Reload the client so it discovers the tools, then ask in plain language: "is example.com up right now, checked from Europe and Asia?", "which of my monitors are down?", "pause the staging monitor until tomorrow".

Claude Code

.mcp.json in your project (or ~/.claude.json for a user-wide connector):

{
  "mcpServers": {
    "hosttracker": {
      "type": "http",
      "url": "https://mcp.host-tracker.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_HOSTTRACKER_API_TOKEN" }
    }
  }
}

Or from the command line:

claude mcp add --transport http hosttracker https://mcp.host-tracker.com/mcp \
  --header "Authorization: Bearer YOUR_HOSTTRACKER_API_TOKEN"

Claude Desktop

The "Add connector" dialog accepts OAuth connectors only, and this server authenticates with a bearer token, so Desktop connects through the mcp-remote bridge. Edit claude_desktop_config.json:

{
  "mcpServers": {
    "hosttracker": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://mcp.host-tracker.com/mcp",
        "--header", "Authorization:${HT_AUTH}"
      ],
      "env": { "HT_AUTH": "Bearer YOUR_HOSTTRACKER_API_TOKEN" }
    }
  }
}

The ${HT_AUTH} indirection is deliberate: some mcp-remote builds split an argument on its first space, which breaks a literal Authorization: Bearer .... Node.js 18 or newer is required.

Cursor

~/.cursor/mcp.json for every project, or .cursor/mcp.json for one:

{
  "mcpServers": {
    "hosttracker": {
      "url": "https://mcp.host-tracker.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_HOSTTRACKER_API_TOKEN" }
    }
  }
}

VS Code (GitHub Copilot agent mode)

.vscode/mcp.json in the workspace. The inputs block keeps the token out of the file, prompting for it once and storing it in the editor's secret storage:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "ht-token",
      "description": "HostTracker API token",
      "password": true
    }
  ],
  "servers": {
    "hosttracker": {
      "type": "http",
      "url": "https://mcp.host-tracker.com/mcp",
      "headers": { "Authorization": "Bearer ${input:ht-token}" }
    }
  }
}

Windsurf

~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "hosttracker": {
      "serverUrl": "https://mcp.host-tracker.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_HOSTTRACKER_API_TOKEN" }
    }
  }
}

Run it yourself (Docker)

The hosted endpoint is the normal way to use the server. If you would rather run your own copy - to read the code, audit it, or keep the MCP hop inside your network - the repository builds it from source:

docker build -t hosttracker-mcp https://github.com/HostTracker/mcp.git
docker run --rm -p 8080:8080 hosttracker-mcp

Your copy then answers at http://localhost:8080/mcp and takes exactly the same Authorization: Bearer header: it is a stateless bridge, so it stores nothing and still talks to the public HostTracker API v2 under your token. Without Docker, dotnet run --project src does the same on any machine with the .NET 10 SDK.

The same binary also speaks stdio, for clients that launch the server as a child process instead of connecting to a URL. Add --stdio and pass your token as the HT_TOKEN environment variable (there is no request header on stdio):

HT_TOKEN=YOUR_HOSTTRACKER_API_TOKEN dotnet run --project src -- --stdio
docker run -i --rm -e HT_TOKEN=YOUR_HOSTTRACKER_API_TOKEN hosttracker-mcp --stdio

Logs go to stderr in that mode, so stdout stays a clean protocol stream.

ChatGPT and other clients

Any client that speaks MCP over streamable HTTP and can send a static header works. Give it the endpoint https://mcp.host-tracker.com/mcp and the header Authorization: Bearer YOUR_HOSTTRACKER_API_TOKEN. Where a client's connector form offers an API-key or custom-header authentication mode, the token goes there; where it offers OAuth only, use the mcp-remote bridge shown under Claude Desktop.

A generic, dependency-free bridge for anything that can only launch a command:

npx -y mcp-remote https://mcp.host-tracker.com/mcp --header "Authorization:${HT_AUTH}"

Longer walkthroughs, verification commands and troubleshooting live in CLIENT.md.

What the assistant can do

The server exposes the HostTracker v2 REST API as MCP tools. Every list tool takes limit (maximum 50) and cursor and returns the next cursor; every timestamp is Unix seconds in both directions; ids are opaque strings.

Three behaviours worth knowing before the first call:

Read the full README on GitHub →