Connect AI assistants (MCP)

Site Qwality runs a Model Context Protocol (MCP) server, so Claude, ChatGPT, Cursor, VS Code and other AI assistants can work with your account. Ask which monitors are down, what happened in last night’s incident, or what the logs said around a failed check, and let the assistant take everyday actions: pause a monitor, acknowledge an incident, post a status page update.

The server URL is:

https://mcp.siteqwality.com/mcp

How signing in works

Add the server URL to your assistant (steps for each one are below).
The assistant opens a Site Qwality consent page in your browser. Sign in if you are not already.
Turn on Read-only if the assistant should only look, then click Allow.

The assistant then acts as you, limited to what you approved. Your role still applies: a Viewer cannot make changes even after granting write access.

To cut an assistant off, revoke it under AI assistants in your personal settings (open the menu under your name, bottom left). It can no longer sign in, and the access it already has stops working within a minute.

Add Site Qwality to your assistant

Works in Claude on the web and in Claude Desktop, on every Claude plan.

Open Customize → Connectors, click +, then Add custom connector.
Name it Site Qwality, paste https://mcp.siteqwality.com/mcp as the URL, and click Add. Leave Advanced settings empty.
Click Connect and approve access on the Site Qwality consent page.
In a chat, turn the connector on from the + menu under Connectors.

On Team and Enterprise plans an Owner adds the connector once under Organization settings → Connectors, and each member then clicks Connect under Customize → Connectors. Free Claude plans allow one custom connector.

claude mcp add --transport http siteqwality https://mcp.siteqwality.com/mcp

Then run /mcp inside Claude Code, pick siteqwality and sign in. Add --scope user to the command to make Site Qwality available in every project, not only the current one.

Add this to ~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "siteqwality": {
      "url": "https://mcp.siteqwality.com/mcp"
    }
  }
}

Cursor opens your browser to sign in when it first connects. If it does not, open Cursor’s MCP settings and click Connect next to siteqwality.

Run MCP: Add Server from the Command Palette, choose HTTP, paste the URL and name it siteqwality. Or add it to .vscode/mcp.json yourself:

{
  "servers": {
    "siteqwality": {
      "type": "http",
      "url": "https://mcp.siteqwality.com/mcp"
    }
  }
}

VS Code opens your browser to sign in the first time the server starts. The tools appear in Copilot Chat under Configure Tools.

Available on the web for ChatGPT Plus, Pro, Business, Enterprise and Edu.

Open Settings → Security and login and turn on Developer mode.
Go to ChatGPT Plugins, click + and create an app named Site Qwality with https://mcp.siteqwality.com/mcp as the server URL and OAuth as the authentication.
Approve access on the Site Qwality consent page.
In a chat, pick Developer mode from the + menu and select Site Qwality.

codex mcp add siteqwality --url https://mcp.siteqwality.com/mcp
codex mcp login siteqwality

The second command opens your browser to sign in. The same server in ~/.codex/config.toml:

[mcp_servers.siteqwality]
url = "https://mcp.siteqwality.com/mcp"

Any other client that supports remote MCP servers over Streamable HTTP with OAuth works the same way: give it the server URL and it will send you to the consent page.

Headless agents and CI

Agents that run without a person at a browser (CI jobs, scheduled scripts, background agents) sign in with an API key instead of the consent page. Send it as a header:

Authorization: Bearer <your API key>

Create it under Settings → API keys → New key, choose Full access (ingest keys cannot call the API), and tick only the scopes the agent needs. A key with no scopes ticked can do everything your account can.

claude mcp add --transport http siteqwality https://mcp.siteqwality.com/mcp \
  --header "Authorization: Bearer $SITEQWALITY_API_KEY"

{
  "mcpServers": {
    "siteqwality": {
      "url": "https://mcp.siteqwality.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SITEQWALITY_API_KEY}"
      }
    }
  }
}

{
  "inputs": [
    {
      "type": "promptString",
      "id": "siteqwality-key",
      "description": "Site Qwality API key",
      "password": true
    }
  ],
  "servers": {
    "siteqwality": {
      "type": "http",
      "url": "https://mcp.siteqwality.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:siteqwality-key}"
      }
    }
  }
}

codex mcp add siteqwality --url https://mcp.siteqwality.com/mcp \
  --bearer-token-env-var SITEQWALITY_API_KEY

Permissions

Access is granted per area, as read:<area> and write:<area>. On the consent page, Read-only grants the read: scopes it offers, and leaving it off grants their write: scopes too. On an API key you tick them one by one, and write does not include read, so tick both if the agent needs both.

Area	Scopes	Covers
Monitors	`read:monitors`, `write:monitors`	HTTP, TCP port, ping, SSL/TLS, domain expiry, cron and browser checks, and reports
Incidents	`read:incidents`, `write:incidents`	Incidents (including those on status pages), escalation policies, on-call schedules, maintenance windows
Notifications	`read:notifications`, `write:notifications`	Notification channels and groups, delivery history, and reading integrations
Status Pages	`read:status_pages`, `write:status_pages`	Status pages with their monitors, layout, maintenance, subscribers, branding and custom domain
Logs	`read:logs`, `write:logs`	Log search, parsers, saved views
Metrics	`read:metrics`, `write:metrics`	Metric queries and saved views
Traces	`read:traces`, `write:traces`	Trace search and detail
RUM	`read:rum`, `write:rum`	RUM applications and analytics
Dashboards	`read:dashboards`, `write:dashboards`	Dashboards, templates, version history and widget queries. Public share links are never available to assistants.
Services	`read:services`, `write:services`	Services and the escalation policy each one routes to
User notification settings	`read:users`, `write:users`	Each user’s contact methods and notification rules

The consent page does not offer the Services and User notification settings scopes, so only an assistant that connects with an API key can reach them. Nor does it offer integrations:manage, the scope for adding, changing or removing an integration; tick it on an API key.

Session replay content is never available to an assistant, whatever it is granted: it stays with the people allowed to watch replays.

What you can ask for

Assistants pick the tool themselves. Write tools need the matching write: scope.

Tool	What it does	Access
`list_attention_items`	Shows what needs attention now: monitors that are down, open incidents, most urgent first.	Read
`list_monitors`	Lists your monitors and their current status.	Read
`get_report`	The report for a day, week or month, each figure beside the period before: uptime against target, outages and downtime, monitors below target, incidents with mean time to acknowledge and resolve, on-call pages, what needs attention now, and real user monitoring. Incidents and on-call need `read:incidents`, and real user monitoring `read:rum`.	Read
`get_monitor`	Shows one monitor’s settings and state.	Read
`get_recent_checks`	Shows a monitor’s latest check results, including the failing step of a browser check.	Read
`get_alert_history`	Shows a monitor’s recent outages, the alerts each one sent and who acknowledged it.	Read
`list_notification_history`	Shows the account’s delivery history, newest first: every alert sent in the last 90 days across monitors and channels, and whether it arrived, failed or was skipped, and why. See check what was sent.	Read
`acknowledge_monitor_outage`	Acknowledges a monitor’s open outage (or the one named by `transition_id`), recording who is on it and, by default, stopping its repeat alerts. See acknowledge a monitor outage.	Write
`list_check_locations`	Lists the locations a check can run from, with the ids to use when creating or updating a monitor.	Read
`create_http_monitor`	Creates an uptime monitor (HTTP, TCP port or ping) that alerts your account’s default notification group. It takes the same `check_type`, `tcp_`, `ping_` and `recheck_on_failure` fields as the API.	Write
`update_http_monitor`	Changes an uptime monitor’s settings, including its TCP port and ping settings. The check type stays as created.	Write
`pause_monitor`, `resume_monitor`	Pauses or resumes a monitor.	Write
`delete_monitor`	Deletes a monitor.	Write, asks first
`run_browser_check`	Runs a browser check now.	Write
`import_monitors`	Imports monitors from UptimeRobot, Pingdom, StatusCake or Better Stack with your API key for that tool, or from CSV text. It previews unless told to create; see import from another tool.	Write
`list_incidents`, `get_incident`	Lists incidents, or shows one with its timeline.	Read
`incident_metrics`	Counts incidents created in a time window and returns mean, p50 and p90 acknowledgment/resolution durations in seconds. Supports service and severity filters; merged incidents are excluded.	Read
`acknowledge_incident`, `resolve_incident`	Acknowledges or resolves an incident. API-key and M2M acknowledgment needs `acknowledged_by`; sessions act as their own member. Resolve accepts a message and `notify_subscribers`.	Write
`create_incident`	Opens an incident, optionally linked to a service and published on a status page. A service’s configured policy pages responders.	Write
`update_incident`	Changes title, severity or service. Omitted fields stay unchanged; `service_id: null` detaches the service. Moving service or increasing severity can start paging.	Write
`reopen_incident`	Reopens a resolved incident, restarting its escalation and posting a public reopening on linked pages. Open and merged incidents are refused.	Write
`post_incident_update`	Adds an update to an incident. A public update (the default) shows on its status pages and can change its status: `resolved` resolves it. It emails subscribers when posted through a named page the incident is on, or with `notify_subscribers`. An internal note stays in the app. Moving public status backwards needs `force: true`.	Write
`publish_incident`	Puts an incident on a status page with a public title and first update, and emails the page’s subscribers unless told not to.	Write
`unpublish_incident`	Takes an incident off a status page. Nothing is emailed and the incident is kept.	Write, asks first
`get_incident_postmortem`	Shows an incident’s postmortem: its Markdown body, review status and owner.	Read
`start_incident_postmortem`	Starts an incident’s postmortem as a draft, prefilled from its timeline unless a body is given.	Write
`update_incident_postmortem`	Edits a postmortem’s body or owner, or moves it to `in_review` or `published`. Publishing needs a resolved incident.	Write
`list_follow_ups`	Lists action items across incidents, soonest due first, each with its incident. Open items by default; filters for owner and overdue.	Read
`add_action_item`, `update_action_item`	Adds a follow-up to an incident with an optional owner, due date and issue link, or edits, closes or reopens one. See postmortems and follow-ups.	Write
`list_incident_templates`	Lists the account’s incident templates.	Read
`create_incident_template`, `update_incident_template`	Saves a template (name, title, message, and optionally severity and status), or changes one.	Write
`delete_incident_template`	Deletes a template. Incidents written from it keep their wording.	Write, asks first
`list_status_pages`	Lists your status pages, each with its public address (`page_url`).	Read
`list_status_page_components`	Lists a status page’s components in page order (monitors, heartbeats, manual and third-party components), with any status set by hand.	Read
`set_status_page_component_status`	Sets what a status page shows for one component, with an optional note and end time.	Write
`clear_status_page_component_status`	Clears that status, so the page follows the monitor again.	Write
`search_logs`	Searches your logs.	Read
`list_metric_names`, `query_metrics`	Lists your metrics, or queries one.	Read
`search_traces`, `get_trace`	Searches your traces, or shows one trace’s spans.	Read

Status pages

These tools use the Status Pages scopes, except the three incident tools (list_status_page_incidents, update_status_page_incident and delete_status_page_incident), which use the Incidents scopes.

Tool	What it does	Access
`get_status_page`	Shows one page and its public address (`page_url`).	Read
`create_status_page`, `rename_status_page`	Creates or renames a page.	Write
`delete_status_page`	Deletes a page.	Write, asks first
`update_status_page_layout`	Replaces the whole layout: groups, their order and the components in each.	Write, asks first
`create_status_page_component`, `update_status_page_component`	Adds a manual component (one with no monitor, whose status you set), or renames it, changes its description or sets its status.	Write
`delete_status_page_component`	Deletes a manual or third-party component.	Write, asks first
`list_third_party_vendors`, `get_third_party_vendor`	Lists the third-party services a page can show, or one service’s components and their current status.	Read
`create_third_party_status_page_component`, `update_third_party_status_page_component`	Adds a third-party service to a page, for the whole service or chosen components, or renames it or changes what it follows.	Write
`list_status_page_monitors`, `get_status_page_monitor`	Lists the HTTP monitors, browser checks and heartbeats (cron jobs) on a page, or shows one with its page name and SLA target.	Read
`add_status_page_monitor`, `update_status_page_monitor`	Adds a monitor or heartbeat to a page, or changes its page name or SLA target.	Write
`remove_status_page_monitor`	Takes a monitor or heartbeat off a page. It keeps running.	Write, asks first
`list_status_page_incidents`	Lists the incidents shown on a page.	Read
`update_status_page_incident`	Changes a page incident’s title or severity. Its status changes through `post_incident_update` or `resolve_incident`.	Write
`delete_status_page_incident`	Deletes an incident shown on a page.	Write, asks first
`list_status_page_maintenances`, `get_status_page_maintenance`	Lists a page’s maintenance windows, or shows one.	Read
`schedule_status_page_maintenance`, `update_status_page_maintenance`	Schedules or changes a maintenance window, with an optional reminder. Each call names what it covers: `whole_page: true`, or the monitors in `affected_http_job_ids`, never both. Confirmed subscribers hear about new and rescheduled windows.	Write
`list_status_page_maintenance_series`	Lists a page’s recurring maintenance, each with its schedule, time zone and next occurrence.	Read
`create_status_page_maintenance_series`, `update_status_page_maintenance_series`	Schedules maintenance that repeats daily, weekly or monthly in a time zone, or changes one. Changes reach the occurrences that have not started.	Write
`delete_status_page_maintenance_series`	Deletes a recurring maintenance and its occurrences that have not started. Past ones stay on the page.	Write, asks first
`delete_status_page_maintenance`	Deletes a maintenance window.	Write, asks first
`list_status_page_subscribers`, `export_status_page_subscribers`	Lists a page’s subscribers on every channel, or exports them all as CSV. Chat and webhook URLs are masked.	Read
`add_status_page_subscriber`	Sends an address a confirmation link, or adds a Slack, Microsoft Teams, Discord, Google Chat or webhook subscriber that is live at once, optionally for only some components or only incidents or maintenance.	Write
`import_status_page_subscribers`	Imports addresses from CSV. Each gets a confirmation link; past the hourly limit they are queued.	Write
`import_status_pages`	Imports status pages from UptimeRobot or Better Stack, showing the monitors you already imported, or a page from Atlassian Statuspage with optional incident history and email subscribers. It previews unless told to create.	Write
`remove_status_page_subscriber`	Removes a subscriber.	Write, asks first
`get_status_page_branding`	Shows a page’s branding.	Read
`update_status_page_branding`, `get_status_page_branding_upload_url`	Changes branding, including the page’s language, or gets an upload link for a logo, dark-theme logo, favicon or social image.	Write
`delete_status_page_branding_asset`	Removes a logo, dark-theme logo, favicon or social image.	Write, asks first
`get_status_page_custom_domain`	Shows a page’s custom domain and the DNS records it needs.	Read
`set_status_page_custom_domain`	Serves a page on your own domain.	Write
`remove_status_page_custom_domain`	Stops serving a page on its custom domain.	Write, asks first
`get_status_page_access`	Shows whether a page is public or private, whether it has a password (never the password itself) and its allowed networks.	Read
`set_status_page_access`	Makes a page private with a password, allowed networks or both, or public again. Any change signs out every visitor.	Write

Services

These tools group monitors into services and decide which failures open incidents. They use the Services scopes. See services.

Tool	What it does	Access
`list_services`, `get_service`	Lists your services with their health, who is on call now, incident settings and monitor counts, filtered by text, team, tag or health; or shows one with the same plus its team, tags, on-call schedule, escalation policy, creation mode, default severity, reopen window, auto-resolve and auto-publish page.	Read
`get_service_metrics`	A service’s incidents, mean time to acknowledge and resolve, and uptime over a window (the last 30 days by default).	Read
`create_service`	Creates a service.	Write
`update_service`	Changes a service’s settings. Omitted fields stay unchanged; `null` clears the description, escalation policy, auto-publish page, team or on-call schedule. Switching to `auto` lets failing monitors open incidents and page.	Write
`list_service_monitors`	Lists every monitor a service groups, of every type, with its status and whether it counts as healthy.	Read
`link_service_monitor`	Adds one monitor to a service and leaves its other monitors alone. A monitor in another service is refused unless `move` is true.	Write
`unlink_service_monitor`	Removes one monitor from a service.	Write, asks first

On-call

These tools use the Incidents scopes. See on-call schedules.

Tool	What it does	Access
`get_on_call_now`	Shows who a schedule has on call now (or at another time), whether through a layer or an override, until when, and who is next.	Read
`list_on_call_shifts`	Shows a schedule’s shifts over a range (the next 14 days by default, at most 90), with overrides applied and gaps included.	Read
`find_on_call_shifts`	Shows who is on call on every schedule now, or one member’s shifts over a range.	Read
`get_on_call_load_report`	Shows the on-call report (the last 30 days by default, at most 90): each member’s shifts, time on call, time covered by overrides, time outside business hours and pages, and each schedule’s covered time and gaps.	Read
`edit_on_call_layer`	Changes a layer’s members and their order, rotation, handoff, zone, covered windows or end, keeping its id. Omitted fields stay as they are, and the old rotation is kept as history. See edit a layer.	Write

Everything else

Two more tools reach everything else the Site Qwality API can do:

Tool	What it does	Access
`find_api_operations`	Searches the API for the operation that does what you asked.	Read
`call_api`	Calls any operation `find_api_operations` found.	Scope of the operation, asks first

Safety

Risky actions are marked. Every tool marked “asks first” above is flagged as destructive, so assistants that honor the flag ask you before running it. Read tools are flagged read-only.
Your data is data. Results include text you and your services control, such as monitor names and log lines. The tools tell the assistant to treat that text as data, never as instructions.
Changes are audited. Every change an assistant makes goes through the same API as the dashboard and shows up in your audit log as the member who approved it, with the assistant’s name, “via MCP” and the tool it used. Connecting and disconnecting an assistant are logged too.
Grant the least you need. Choose read-only when you only want answers. You can reconnect with write access later.

Agent skill

Coding agents that read agent skills (Claude Code, Codex, Cursor and others) can install the Site Qwality skill, which tells the agent how to connect this server or call the API with a key, and to confirm before deleting or publishing anything:

npx skills add siteqwality/skills

The source is at github.com/siteqwality/skills.

Partner and agency accounts

If you manage client accounts, an assistant can work in one of them when your client lets you set custom headers (Claude Code, Cursor, VS Code and Codex CLI do). Add this header next to the server URL:

X-SQ-Account: <client account id>

It works only when you signed in through the consent page: API keys cannot switch accounts. See Working in a client account.

Troubleshooting

Problem	Fix
The assistant stopped working after you revoked it, or says it is not authorized (`401`)	Connect again: Connect in Claude, `/mcp` in Claude Code, `codex mcp login siteqwality` in Codex, or remove and re-add the server elsewhere.
`403` on an action	The access you approved does not cover it. Revoke it under AI assistants in your personal settings and reconnect with read and write, or add the scope to your API key. A `403` can also mean your role does not allow the action, or a plan limit was reached; the message says which.
`404` with `X-SQ-Account` set	The client id is wrong, or you are using an API key. See Working in a client account.
The assistant cannot find a tool for what you asked	Ask it to use `find_api_operations`.
`429`	The MCP server allows 300 requests a minute per key or user. Wait for the seconds in `Retry-After`. See rate limits.