PagerDuty's official MCP Server

PagerDuty's local MCP (Model Context Protocol) server which provides tools to interact with your PagerDuty account, allowing you to manage incidents, services, schedules, event orchestrations, and more directly from your MCP-enabled client.

Embedded MCP Apps (Developer Experience)

Interactive React UIs for PagerDuty incident management, embedded directly in the Python MCP server for seamless IDE integration. Manage your full incident lifecycle without leaving your IDE.

Available Apps:

1. Incident Command Center 🚨

Full incident lifecycle management from your IDE:

Real-time incident feed with auto-refresh
Deep incident details: timeline, notes, alerts, changes
Quick actions: acknowledge, resolve, escalate
AI-powered similar incident detection
Alert inspection with raw data

Usage in VS Code: Ask Claude: Show me the incident command center

2. On-Call Manager 📅

Schedule management with override CRUD and coverage wizards:

View current on-call rotations across schedules
Create, edit, and delete schedule overrides
Escalation policy management with modal-based UI

Usage in VS Code: Ask Claude: Show me the on-call manager

3. On-Call Compensation Report 💰

Per-user on-call metrics with compliance tracking:

Hours worked, incident counts, interruption rates
Business hours vs. off-hours breakdown
Compliance status with EU Working Time Directive limits
Fairness/equity scoring across responders
CSV export

Usage in VS Code: Ask Claude: Show me the oncall compensation report

4. Service Dependency Graph 🕸️

Interactive graph of service relationships and dependencies:

Directed graph visualization
Impact sidebar showing upstream/downstream services

Usage in VS Code: Ask Claude: Show me the service dependency graph

5. Onboarding Wizard 🧙

Step-by-step PagerDuty account setup:

Team creation and user onboarding
Schedule setup with timezone support
Escalation policy and service configuration
AIOps / alert grouping configuration
Incident workflow setup

Usage in VS Code: Ask Claude: Open the onboarding wizard

Architecture:

✅ Native VS Code integration (MCP resources)
✅ Single process, no HTTP server management
✅ Direct access to all PagerDuty MCP tools
✅ Simple deployment: uv run pagerduty-mcp

Prerequisites

asdf-vm installed.
uv installed globally.
A PagerDuty User API Token. To obtain a PagerDuty User API Token, follow these steps:
1. Navigate to User Settings. Click on your user profile icon, then select My Profile and then User Settings.
  
  For Freemium accounts, the permissions for generating User API tokens are limited to the user role as defined here.
2. In your user settings, locate the API Access section.
3. Click the Create API User Token button and follow the prompts to generate a new token.
4. Copy the generated token and store it securely. You will need this token to configure the MCP server.
Use of the PagerDuty User API Token is subject to the PagerDuty Developer Agreement.

Using with MCP Clients

Cursor Integration

You can configure this MCP server directly within Cursor's settings.json file, by following these steps:

Open Cursor settings (Cursor Settings > Tools > Add MCP, or Cmd+, on Mac, or Ctrl+, on Windows/Linux).

Add the following configuration:

{
  "mcpServers": {
    "pagerduty-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "pagerduty-mcp",
        "--enable-write-tools"
        // This flag enables write operations on the MCP Server enabling you to creating incidents, schedule overrides and much more
      ],
      "env": {
        "PAGERDUTY_USER_API_KEY": "${input:pagerduty-api-key}"
      }
    }
  }
}

VS Code Integration

You can configure this MCP server directly within Visual Studio Code's settings.json file, allowing VS Code to manage the server lifecycle.

Open VS Code settings (File > Preferences > Settings, or Cmd+, on Mac, or Ctrl+, on Windows/Linux).
Search for "mcp" and ensure "Mcp: Enabled" is checked under Features > Chat.
Click "Edit in settings.json" under "Mcp > Discovery: Servers".

Add the following configuration:

{
    "mcp": {
        "inputs": [
            {
                "type": "promptString",
                "id": "pagerduty-api-key",
                "description": "PagerDuty API Key",
                "password": true
            }
        ],
        "servers": {
            "pagerduty-mcp": { 
                "type": "stdio",
                "command": "uvx",
                "args": [
                    "pagerduty-mcp",
                    "--enable-write-tools"
                    // This flag enables write operations on the MCP Server enabling you to creating incidents, schedule overrides and much more
                ],
                "env": {
                    "PAGERDUTY_USER_API_KEY": "${input:pagerduty-api-key}",
                    "PAGERDUTY_API_HOST": "https://api.pagerduty.com"
                    // If your PagerDuty account is located in EU update your API host to https://api.eu.pagerduty.com
                }
            }
        }
    }
}

Trying it in VS Code Chat (Agent)

Ensure MCP is enabled in VS Code settings (Features > Chat > "Mcp: Enabled").
Configure the server as described above.
Open the Chat view in VS Code (View > Chat).
Make sure Agent mode is selected. In the Chat view, you can enable or disable specific tools by clicking the 🛠️ icon.
Enter a command such as Show me the latest incident or List my event orchestrations to interact with your PagerDuty account through the MCP server.
You can start, stop, and manage your MCP servers using the command palette (Cmd+Shift+P/Ctrl+Shift+P) and searching for MCP: List Servers. Ensure the server is running before sending commands. You can also try to restart the server if you encounter any issues.

Claude Desktop Integration

You can configure this MCP server to work with Claude Desktop by adding it to Claude's configuration file.

Locate your Claude Desktop configuration file:
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json

Create or edit the configuration file and add the following configuration:

{
  "mcpServers": {
    "pagerduty-mcp": {
      "command": "uvx",
      "args": [
        "pagerduty-mcp",
        "--enable-write-tools"
      ],
      "env": {
        "PAGERDUTY_USER_API_KEY": "your-pagerduty-api-key-here",
        "PAGERDUTY_API_HOST": "https://api.pagerduty.com"
      }
    }
  }
}

Replace the placeholder values:
- Replace /path/to/your/mcp-server-directory with the full path to the directory where you cloned the MCP server (e.g., /Users/yourname/code/pagerduty-mcp)
- Replace your-pagerduty-api-key-here with your actual PagerDuty User API Token
- If your PagerDuty account is located in the EU, update the API host to https://api.eu.pagerduty.com
Restart Claude Desktop completely for the changes to take effect.
Test the integration by starting a conversation with Claude and asking something like "Show me my latest PagerDuty incidents" or "List my event orchestrations" to verify the MCP server is working.

Security Note: Unlike VS Code's secure input prompts, Claude Desktop requires you to store your API key directly in the configuration file. Ensure this file has appropriate permissions (readable only by your user account) and consider the security implications of storing credentials in plain text.

Running with Docker

The PagerDuty MCP server can be run in a Docker container, providing an isolated and portable deployment option. The Docker image uses stdio transport for MCP communication.

Prerequisites

Docker installed
A PagerDuty User API Token (see Prerequisites)

Quick Start

Build the Docker image:

docker build -t pagerduty-mcp:latest .

Run in read-only mode (default):

docker run -i --rm \
  -e PAGERDUTY_USER_API_KEY="your-api-key-here" \
  pagerduty-mcp:latest

Run with write tools enabled:

docker run -i --rm \
  -e PAGERDUTY_USER_API_KEY="your-api-key-here" \
  pagerduty-mcp:latest --enable-write-tools

For EU region:

docker run -i --rm \
  -e PAGERDUTY_USER_API_KEY="your-api-key-here" \
  -e PAGERDUTY_API_HOST="https://api.eu.pagerduty.com" \
  pagerduty-mcp:latest

Using with MCP Clients via Docker

To integrate the Docker container with MCP clients, you can use Docker as the command:

Claude Desktop example:

{
  "mcpServers": {
    "pagerduty-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "PAGERDUTY_USER_API_KEY=your-api-key-here",
        "pagerduty-mcp:latest"
      ]
    }
  }
}

Note: The Docker container uses stdio transport, making it compatible with MCP clients that expect standard input/output communication. Ensure you build the image first using docker build -t pagerduty-mcp:latest .

Transport modes

The server supports three MCP transports, selected via the --transport flag:

Transport	Use case	Default
`stdio`	Local clients launched as a subprocess (Cursor, VS Code).	✅
`streamable-http`	Long-running remote/server deployments. MCP endpoint at `/mcp`.
`sse`	Legacy Server-Sent Events transport.

For HTTP-based transports, --host (default 127.0.0.1) and --port (default 8000) control the listen address. These can also be set via environment variables MCP_HOST and MCP_PORT. Note: MCP_PORT must always be a valid integer — the CLI parses its type at startup regardless of --transport; range validation (1–65535) only applies for HTTP transports.

⚠️ Security — HTTP transports have no built-in authentication. When running streamable-http or sse, the MCP endpoint is exposed with no authentication, and every request uses the single PAGERDUTY_USER_API_KEY the server was started with. Any client that can reach the host/port can invoke tools — including write tools when --enable-write-tools is set — with that key's full PagerDuty privileges.

The default bind address is 127.0.0.1 (loopback only) — keep it that way for local use.

Only bind to 0.0.0.0/a routable address when the endpoint sits behind an authenticating reverse proxy / API gateway (e.g. oauth2-proxy, mTLS) or on a trusted network. Do not expose it directly to untrusted networks.

Example: run as a remote streamable-HTTP server

pagerduty-mcp --transport streamable-http --host 0.0.0.0 --port 8000
# MCP endpoint: http://<your-machine-ip>:8000/mcp
# ⚠️ Only use --host 0.0.0.0 behind an authenticating proxy or on a trusted network.

Using environment variables:

MCP_HOST=0.0.0.0 MCP_PORT=8000 pagerduty-mcp --transport streamable-http
# ⚠️ Only use MCP_HOST=0.0.0.0 behind an authenticating proxy or on a trusted network.

Docker:

docker run -d -p 8000:8000 \
  -e PAGERDUTY_USER_API_KEY="your-api-key-here" \
  -e MCP_HOST=0.0.0.0 \
  -e MCP_PORT=8000 \
  pagerduty-mcp:latest \
  --transport streamable-http
# ⚠️ Only use MCP_HOST=0.0.0.0 behind an authenticating proxy or on a trusted network.

The default remains stdio so existing local integrations are unaffected.

Set up locally

Clone the repository

Install asdf plugins

asdf plugin add python
asdf plugin add nodejs https://github.com/asdf-vm/asdf-nodejs.git
asdf plugin add uv

Install tool versions using asdf:
```
asdf install
```
Create a virtual environment and install dependencies using uv (now that asdf has set the correct Python and uv versions):
```
uv sync
```
Ensure uv is available globally.

The MCP server can be run from different places so you need uv to be available globally. To do so, follow the official documentation.

Tip: You may need to restart your terminal and/or VS Code for the changes to take effect.

Run it locally

To run your cloned PagerDuty MCP Server you need to update your configuration to use uv instead of uvx.

"pagerduty-mcp": { 
    "type": "stdio",
    "command": "uv",
    "args": [
        "run",
        "--directory",
        "/path/to/your/mcp-server-directory",
        // Replace with the full path to the directory where you cloned the MCP server, e.g. "/Users/yourname/code/mcp-server",     
        "python",
        "-m",
        "pagerduty_mcp",
        "--enable-write-tools"
        // This flag enables write operations on the MCP Server enabling you to creating incidents, schedule overrides and much more
    ],
    "env": {
        "PAGERDUTY_USER_API_KEY": "${input:pagerduty-api-key}",
        "PAGERDUTY_API_HOST": "https://api.pagerduty.com"
        // If your PagerDuty account is located in EU update your API host to https://api.eu.pagerduty.com
    }
}

Configuration

The MCP server is configured via environment variables:

Environment Variable	Required	Default	Description
`PAGERDUTY_USER_API_KEY`	Yes	—	Your PagerDuty User API Token.
`PAGERDUTY_API_HOST`	No	`https://api.pagerduty.com`	PagerDuty API base URL. Use `https://api.eu.pagerduty.com` for EU accounts.

Available Tools and Resources

This section describes the tools provided by the PagerDuty MCP server. They are categorized based on whether they only read data or can modify data in your PagerDuty account.

Important: By default, the MCP server only exposes read-only tools. To enable tools that can modify your PagerDuty account (write-mode tools), you must explicitly start the server with the --enable-write-tools flag. This helps prevent accidental changes to your PagerDuty data.

Tool	Area	Description	Read-only
create_alert_grouping_setting	Alert Grouping	Creates a new alert grouping setting	❌
delete_alert_grouping_setting	Alert Grouping	Deletes an alert grouping setting	❌
get_alert_grouping_setting	Alert Grouping	Retrieves a specific alert grouping setting	✅
list_alert_grouping_settings	Alert Grouping	Lists alert grouping settings with filtering	✅
update_alert_grouping_setting	Alert Grouping	Updates an existing alert grouping setting	❌
get_incident_metrics_all	Analytics	Retrieves aggregated incident metrics across all services	✅
get_incident_metrics_by_service	Analytics	Retrieves incident metrics grouped by service	✅
get_incident_metrics_by_team	Analytics	Retrieves incident metrics grouped by team	✅
get_responder_load_metrics	Analytics	Retrieves responder load metrics	✅
get_responder_metrics	Analytics	Retrieves responder performance metrics	✅
get_business_service_dependencies	Business Services	Retrieves dependencies for a specific business service	✅
get_technical_service_dependencies	Business Services	Retrieves technical service dependencies for a business service	✅
list_business_services	Business Services	Lists business services	✅
get_change_event	Change Events	Retrieves a specific change event	✅
list_change_events	Change Events	Lists change events with optional filtering	✅
list_incident_change_events	Change Events	Lists change events related to a specific incident	✅
list_service_change_events	Change Events	Lists change events for a specific service	✅
get_event_orchestration	Event Orchestrations	Retrieves a specific event orchestration	✅
get_event_orchestration_global	Event Orchestrations	Gets the global orchestration configuration for an event orchestration	✅
get_event_orchestration_router	Event Orchestrations	Gets the router configuration for an event orchestration	✅
get_event_orchestration_service	Event Orchestrations	Gets the service orchestration configuration for a specific service	✅
list_event_orchestrations	Event Orchestrations	Lists event orchestrations with optional filtering	✅
update_event_orchestration_router	Event Orchestrations	Updates the router configuration for an event orchestration	❌
append_event_orchestration_router_rule	Event Orchestrations	Adds a new routing rule to an event orchestration router	❌
create_escalation_policy	Escalation Policy	Creates a new escalation policy	❌
get_escalation_policy	Escalation Policy	Retrieves a specific escalation policy	✅
list_escalation_policies	Escalation Policy	Lists escalation policies	✅
update_escalation_policy	Escalation Policy	Updates an existing escalation policy	❌
add_note_to_incident	Incidents	Adds note to an incident	❌
add_responders	Incidents	Adds responders to an incident	❌
create_incident	Incidents	Creates a new incident	❌
get_alert_from_incident	Incidents	Retrieves a specific alert from an incident	✅
get_incident	Incidents	Retrieves a specific incident	✅
get_outlier_incident	Incidents	Retrieves outlier incident information for a specific incident	✅
get_past_incidents	Incidents	Retrieves past incidents related to a specific incident	✅
get_related_incidents	Incidents	Retrieves related incidents for a specific incident	✅
list_alerts_from_incident	Incidents	Lists all alerts for a specific incident with pagination	✅
list_incident_notes	Incidents	Lists all notes for a specific incident	✅
list_incidents	Incidents	Lists incidents	✅
manage_incidents	Incidents	Updates status, urgency, assignment, or escalation level	❌
get_incident_workflow	Incident Workflows	Retrieves a specific incident workflow	✅
list_incident_workflows	Incident Workflows	Lists incident workflows with optional filtering	✅
start_incident_workflow	Incident Workflows	Starts a workflow instance for an incident	❌
get_log_entry	Log Entries	Retrieves a specific log entry by ID	✅
list_log_entries	Log Entries	Lists all log entries across the account with time filtering	✅
add_team_member	Teams	Adds a user to a team with a specific role	❌
create_team	Teams	Creates a new team	❌
delete_team	Teams	Deletes a team	❌
get_team	Teams	Retrieves a specific team	✅
list_team_members	Teams	Lists members of a team	✅
list_teams	Teams	Lists teams	✅
remove_team_member	Teams	Removes a user from a team	❌
update_team	Teams	Updates an existing team	❌
get_user_data	Users	Gets the current user's data	✅
list_users	Users	Lists users in the PagerDuty account	✅
list_oncalls	On-call	Lists on-call schedules	✅
list_priorities	Priorities	Lists priorities defined in the account	✅
create_schedule_override	Schedules	Creates an override for a schedule	❌
get_schedule	Schedules	Retrieves a specific schedule	✅
list_schedule_users	Schedules	Lists users in a schedule	✅
list_schedules	Schedules	Lists schedules	✅
create_schedule	Schedules	Creates a new on-call schedule	❌
update_schedule	Schedules	Updates an existing schedule	❌
create_service	Services	Creates a new service	❌
get_service	Services	Retrieves a specific service	✅
list_services	Services	Lists services	✅
update_service	Services	Updates an existing service	❌
create_status_page_post	Status Pages	Creates a new post (incident or maintenance) on a status page	❌
create_status_page_post_update	Status Pages	Adds a new update to an existing status page post	❌
get_status_page_post	Status Pages	Retrieves details of a specific status page post	✅
list_status_page_impacts	Status Pages	Lists available impact levels for a status page	✅
list_status_page_post_updates	Status Pages	Lists all updates for a specific status page post	✅
list_status_page_severities	Status Pages	Lists available severity levels for a status page	✅
list_status_page_statuses	Status Pages	Lists available statuses for a status page	✅
list_status_pages	Status Pages	Lists all status pages with optional filtering	✅
create_webhook_subscription	Webhooks	Creates a new webhook subscription (returns signing secret)	❌
delete_webhook_subscription	Webhooks	Deletes a webhook subscription	❌
get_webhook_subscription	Webhooks	Retrieves a specific webhook subscription	✅
list_webhook_subscriptions	Webhooks	Lists webhook subscriptions with optional type filtering	✅
update_webhook_subscription	Webhooks	Updates an existing webhook subscription	❌
get_extension_schema	Extension Schemas	Retrieves a specific extension schema	✅
list_extension_schemas	Extension Schemas	Lists available extension schemas (vendors)	✅

Support

PagerDuty's MCP server is an open-source project, and as such, we offer only community-based support. If assistance is required, please open an issue in GitHub or PagerDuty's community forum.

Contributing

If you are interested in contributing to this project, please refer to our Contributing Guidelines.