Menu
Mattering Automations connector

A PagerDuty MCP for automations that respect the on-call rotation

Connect a PagerDuty API key and on-call lookups, incident reads, acknowledgements, notes, schedule overrides and escalation policy changes become workflow steps. An agent can answer who is on call right now and route a message to that person, a workflow can post what a runbook did into the incident timeline, and the two nodes that actually page a human are flagged destructive so nothing wakes anyone by accident.

50 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the PagerDuty MCP connector does

The PagerDuty connector for Mattering Automations is 50 nodes on PagerDuty's REST API and Events API v2: incidents from list and get through manage, merge, snooze, alerts and notes, the on-call read that answers who is carrying the pager right now, schedules and overrides, escalation policies, services, users, teams and team members, maintenance windows, account priorities and abilities, and the two Analytics reads that return incident and per-service metrics over a date range. 24 nodes read and 26 act.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can pull an incident, read its full timeline and its alert payloads, check who is on call for the service, and write a note back saying what it found, without anyone opening the PagerDuty web app.

PagerDuty publishes an official MCP server of its own, read-only by default, and for a person asking a chat client about an incident that is a reasonable tool. This connector is a different shape. These nodes run inside scheduled and triggered automations next to every other connector on the platform, so the on-call lookup can feed a Mattering Comms message, the incident note can be written by a workflow at three in the morning rather than by somebody asking a chatbot, and the writes are available when you want them with the dangerous ones marked.

The safety modeling is the part worth reading twice, because this is a paging product. Seven nodes are flagged destructive: the five deletes for services, escalation policies, schedules, users and teams, plus PagerDuty: Create Incident and PagerDuty: Trigger Event. Those last two delete nothing. They are flagged because they open a real incident on a real service and page whoever is on call for it, on a phone, at whatever hour it is where that person lives, and resolving the incident afterwards does not un-wake anyone. Two more carry warnings without the flag: PagerDuty: Snooze Incident means nobody is being told about the incident while it runs, and PagerDuty: Create Maintenance Window suppresses alerting on the named services, so a real outage that starts inside the window is invisible until it ends.

One connection, three surfaces

  • Visual automations. Drag PagerDuty nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every PagerDuty node, ready to drop on the canvas

50 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 24

PagerDuty: Get Escalation Policy

Fetch one escalation policy with every rule in order: the delay before each level, the users and schedules targeted at each level, how many times the whole thing loops, and which services depend on it. Read this before updating, because the update endpoint replaces the whole rule list.

PagerDuty: Get Incident

Fetch one incident in full: status, urgency, priority, service, escalation policy, current assignees, acknowledgements, alert counts, whether it can be merged, and the conference bridge if one is attached. Accepts either the incident ID or the incident number. Richer than a row from List Incidents, which is why it is worth a second call before acting on one.

PagerDuty: Get Incident Metrics

Aggregated incident metrics across the account for a date range: incident counts, escalations, notifications, interruptions split by business, off and sleep hours, engaged seconds, and the mean times to acknowledge, engage, mobilize and resolve. Set aggregate_unit to day, week or month for a time series; leave it blank for one row covering the whole period. This is a POST because the filters go in the body, but it reads and changes nothing. Two things to know before trusting the numbers: the data pipeline runs behind live, generally within 24 hours, so the most recent bucket may still be filling in; and a user-level or OAuth key MUST supply a team or service filter, while an account-level key need not.

PagerDuty: Get Schedule

Fetch one schedule with its layers: who rotates, how long each turn lasts, the daily or weekly restrictions, and the rendered shifts for a date range. Set since and until to see who is actually on for a given period, including the final schedule after overrides are applied.

PagerDuty: Get Service

Fetch one service: its escalation policy, teams, integrations, alert grouping, support hours, auto-resolve and acknowledgement timeouts, and its current status. Read this before changing a service, because the update endpoint replaces whole objects rather than merging them.

PagerDuty: Get Service Metrics

The same incident metrics broken down PER SERVICE, plus an uptime percentage per service. Each row carries service_id, service_name, team_id and team_name, so this is the read behind a service scorecard: which service pages people most, which one takes longest to resolve, which one wakes people at night. Set aggregate_unit for a per-service time series, or leave it blank for one row per service over the whole period. Reads only, despite being a POST. Data lags live by up to about a day.

PagerDuty: Get Team

Fetch one team: name, description and default role, which is what decides whether people outside the team can see its incidents at all. A default_role of none makes the team private.

PagerDuty: Get User

Fetch one person: email, role, job title, time zone, teams, contact methods and notification rules. Ask for contact_methods in include to find out HOW this person is reachable, which is the question behind most escalation debugging. Note that requesting calendar_urls returns feed URLs that act as bearer credentials for that person's on-call calendar, so do not log or forward them.

PagerDuty: List Abilities

List the feature names this account has, such as teams, urgencies and service_support_hours. The cheapest authenticated read in the whole API: no parameters, no path, a short array of strings. Use it as the credential health check, and to find out before a run whether a feature a later node depends on is even available on this account.

PagerDuty: List Escalation Policies

List escalation policies with their rules, delays, targets and the services they cover. An escalation policy is the answer to who gets paged, in what order and after how long, so this is the read behind any question about paging coverage. Search by name with query, or filter to the policies a given user is a target on.

PagerDuty: List Incident Alerts

List the alerts grouped into one incident, each with its severity, de-duplication key, integration, suppression flag and the custom details the sending tool attached. This is where the actual monitoring payload lives: the incident is the human-facing wrapper, the alert body carries the machine data.

PagerDuty: List Incident Log Entries

The full timeline of one incident: every trigger, notification, acknowledgement, escalation, reassignment, note and resolution, with who or what did it and when. This is the node to read when an automation needs to know what already happened before it acts. Set is_overview to true for just the important steps.

PagerDuty: List Incident Notes

List the notes responders have added to an incident, with the author, the channel it came from and the timestamps. Notes are the human running commentary, so this is what to summarise into a status update or a chat channel.

PagerDuty: List Incidents

List incidents, filtered by status, urgency, service, team, assigned user, or a created-at date range. The workhorse read: point it at statuses triggered and acknowledged to get everything currently demanding attention. The date range defaults to the last month and PagerDuty caps it at six months. Returns data.incidents[] with limit, offset and more for paging.

PagerDuty: List Log Entries

Every logged event across the whole account: triggers, notifications, acknowledgements, escalations, reassignments, notes and resolutions, newest first, over a date range. This is the audit read behind questions like how many pages went out last night and who answered them. Set is_overview to true to drop the notification noise. For one incident's timeline use List Incident Log Entries, which is the only way to filter by incident.

PagerDuty: List Maintenance Windows

List maintenance windows, which are the periods during which a service creates no incidents. Filter to ongoing to answer the question that matters during an outage: is this service quiet because nothing is wrong, or because somebody suppressed it? Filter to future to audit what is scheduled.

PagerDuty: List On Calls

Who is on call, and when. Each row pairs a user with the schedule and escalation policy that puts them there, at which escalation level, for which stretch of time. With no date range it answers who is on call right now, which is the single most useful read in this connector: put it in front of a Comms message and the right person gets pinged instead of everybody. Set earliest to true for just the next shift per policy and level. PagerDuty applies operation-specific rate limits to this endpoint, so poll it kindly.

PagerDuty: List Priorities

List the account's incident priorities in order, most to least severe, with their IDs, names and descriptions. The priority ID from here is what Create Incident and Manage Incident want. Accounts without the priorities feature get an empty list.

PagerDuty: List Schedule Overrides

List the overrides on a schedule for a time range: who is covering for whom, and when. since and until are both REQUIRED, which is unusual for this API. Set editable to true to get only future overrides that can still be removed, which is what you need before calling Delete Schedule Override.

PagerDuty: List Schedules

List on-call schedules with their IDs, time zones and the escalation policies they feed. Search by name with query. The schedule ID from here feeds the override nodes and the on-call lookup.

PagerDuty: List Services

List the services incidents can be opened against, with their IDs, current status, escalation policy, teams, integrations and auto-resolve settings. Search by name with query. The service ID from here feeds incident creation, maintenance windows and every service picker in this connector.

PagerDuty: List Team Members

List who is on a team and what role each person holds there: observer, responder or manager. Rows are data.members[].user with a sibling role, not plain user objects, so read the path carefully when mapping downstream.

PagerDuty: List Teams

List the teams on the account with their IDs, names and descriptions. Search by name with query. Teams scope almost every other lister in this connector, so the team ID from here is what narrows incidents, services and schedules to one group of people. Account must have the teams feature.

PagerDuty: List Users

List the people on the account with their IDs, emails, roles, job titles, time zones and teams. Search by name or email with query. The user ID from here feeds schedule overrides, incident assignment and team membership; the EMAIL is what the From header on every write node wants.

Action nodes 26

PagerDuty: Acknowledge or Resolve Event

Acknowledge or resolve an alert through the Events API using the de-duplication key it was triggered with. This is the closing half of a self-healing automation: your workflow triggered the page, fixed the thing, and now resolves it. Nobody is paged by this node. It uses the same ROUTING KEY as Trigger Event, not the REST API key, and the dedup key must match an open alert or PagerDuty accepts the event and does nothing.

PagerDuty: Add Incident Note

Add a note to an incident, attributed to the person in the From email. Notes appear in the incident timeline and in responder notifications, so this is the polite way for an automation to say what it did: which runbook it ran, what it found, what a human still needs to do. Adding a note does not page anyone. PagerDuty allows up to 2000 notes on one incident.

PagerDuty: Create Escalation Policy

Create an escalation policy: the ordered list of who to page and how long to wait before escalating. At least one escalation rule is required, and each rule targets users or schedules. Reversible with Delete Escalation Policy while no service uses it. The From email is OPTIONAL on this endpoint and is used only for change tracking.

PagerDuty: Create Incident

DESTRUCTIVE: opens a real incident on a real service, which PAGES THE PEOPLE ON CALL for that service's escalation policy, on their phones, at whatever hour it is where they are. That side effect leaves the system and cannot be taken back: resolving the incident afterwards does not un-wake anyone. Never point this at a production service from a test run, and never include it in an unattended endpoint matrix. Use it when something outside PagerDuty has genuinely detected a problem a human must handle now. Set incident_key to make repeated runs de-duplicate into one incident instead of paging repeatedly.

PagerDuty: Create Maintenance Window

Open a maintenance window, which SUPPRESSES ALERTING on the named services for its duration: no incidents are created, so nobody is paged, so a real outage that starts during the window is invisible until it ends. That is the whole point during a planned deploy and a serious hazard when the window is longer than the work. Keep them short, name the services precisely, and prefer ending one early with Delete Maintenance Window over leaving a wide one open. If the start time is in the past PagerDuty moves it to now. Reversible: delete the window and alerting resumes.

PagerDuty: Create Schedule

Create an on-call schedule from one or more rotation layers. Each layer names its users, when the rotation starts, how long a turn lasts, and any daily or weekly restriction. A schedule on its own pages nobody: it starts mattering once an escalation policy targets it. Reversible with Delete Schedule.

PagerDuty: Create Schedule Override

Put a specific person on call for a specific window, on top of whatever the rotation says. This is the node behind sick days, holidays and follow-the-sun handovers. The person named here WILL be paged for anything that arrives during the window, so make sure they know. A later override on the same window wins. Reversible with Delete Schedule Override while the window is still in the future.

PagerDuty: Create Service

Create a service, which is the thing incidents get opened against and the thing an escalation policy points at. A new service must be created with status active. Reversible with Delete Service while it has no history worth keeping. PagerDuty allows up to 25,000 services per account.

PagerDuty: Create Team

Create a team, the grouping that owns services, schedules and escalation policies and scopes who sees what. Set default_role to none for a private team whose incidents are hidden from non-members. Reversible with Delete Team while it owns nothing.

PagerDuty: Create User

Add a person to the account. PagerDuty EMAILS THEM AN INVITATION at the address given, so point automated runs at an address you own. A new user has no contact methods beyond that email and no notification rules, so they will not be paged usefully until those are set up. Reversible with Delete User. Adding a user may affect billing, which is between you and PagerDuty and is not something this node can tell you.

PagerDuty: Delete Escalation Policy

DESTRUCTIVE: delete an escalation policy and all of its rules. PagerDuty refuses while any service still uses it, which is the guard rail that stops this silently breaking paging. Take that refusal seriously: the way people get around it is to repoint the service at some other policy first, and if that other policy targets the wrong rotation then incidents on that service now wake up the wrong people, or nobody. There is no undelete, and rebuilding a policy means rebuilding every rule, delay and target by hand.

PagerDuty: Delete Maintenance Window

Delete a future maintenance window, or END one that is running now so alerting resumes immediately. A window that has already finished cannot be deleted. This is the safety valve for the create node, so it is classed as a reversible write rather than destructive: the effect is to turn paging back ON.

PagerDuty: Delete Schedule

DESTRUCTIVE: delete an on-call schedule, its layers and its rotation history. If an escalation policy targets this schedule, that level of the policy now has nobody behind it, so incidents can escalate past it to whoever is next, or to nobody at all. PAGING FOR EVERY SERVICE ON THAT POLICY CAN BREAK SILENTLY, and it breaks at the worst moment, when something is already on fire. Check List Escalation Policies for references first. There is no undelete.

PagerDuty: Delete Schedule Override

Remove an override, handing the window back to the normal rotation. A PAST override cannot be removed; one that is currently running is truncated to now instead of deleted, and PagerDuty signals that by returning 200 rather than 204. Reversible by creating the override again, which is why this is not classed Destructive.

PagerDuty: Delete Service

DESTRUCTIVE: delete a service. It disappears from the web UI, its integrations stop working, and NO NEW INCIDENTS CAN BE CREATED FOR IT, so any monitoring tool still sending events to its routing keys is now shouting into the void with nobody paged. Its incident history goes with it. There is no undelete. If the goal is to stop the noise temporarily, set status to disabled with Update Service instead, or open a maintenance window.

PagerDuty: Delete Team

DESTRUCTIVE: remove a team. PagerDuty refuses while the team still owns escalation policies, services, schedules or subteams, which is the guard rail. Unresolved incidents move to the reassignment team if you name one, and OTHERWISE LOSE THEIR TEAM ENTIRELY and become account-level, which widens who can see them. Reassignment is asynchronous and may not have finished when this call returns. There is no undelete.

PagerDuty: Delete User

DESTRUCTIVE: remove a person from the account. They lose access immediately, their contact methods and notification rules go with them, and they vanish from every schedule layer and escalation rule that named them. THAT IS THE DANGEROUS PART: a rotation with a hole in it, or an escalation level with no targets left, still looks configured while quietly paging nobody. PagerDuty returns 400 if the person still has assigned incidents, unless the account has the offboarding feature configured, in which case reassignment happens asynchronously and may not be finished when this call returns. There is no undelete.

PagerDuty: Manage Incident

Acknowledge, resolve, reassign, re-prioritise or escalate one incident. This is the node most automations want: set status to acknowledged to stop the escalation clock, or resolved to close it out with a resolution note. Reversible in both directions, since setting a resolved incident back to triggered or acknowledged REOPENS it. Reopening does page again, so treat un-resolving as an action with a real audience.

PagerDuty: Merge Incidents

Merge several incidents into one. The target keeps every alert from the sources and the SOURCE INCIDENTS ARE RESOLVED, which is the part to understand before automating it: five pages become one incident and four resolutions. Reversible in the sense that an alert can be moved back out with Update Alert, but the source incidents stay resolved, so this is not a clean undo. Only incidents that have alerts, or were created by hand in the UI, can be merged, the target must be open, and one incident cannot end up with more than 1000 alerts.

PagerDuty: Snooze Incident

Silence an incident for a number of seconds. Nobody is paged about it again until the time is up, at which point it returns to triggered and notifies as normal. Useful for a known condition with a scheduled fix. Worth saying plainly: while an incident is snoozed the on-call is NOT being told about it, so an automation that snoozes on a loop hides a real problem. Reversed by resolving the incident or by acknowledging it.

PagerDuty: Trigger Event

DESTRUCTIVE: sends a trigger event to the PagerDuty Events API, which opens an alert and an incident and PAGES THE ON-CALL ROTATION for the service behind the routing key. A real person gets a phone call or a push notification, possibly at 3am, and that cannot be undone by resolving afterwards. NEVER run this in a blind endpoint test matrix, and never point it at a production routing key while testing. This node uses a ROUTING KEY, not the REST API key: it is the Integration Key of an Events API v2 integration on the service you want to page, and it is what selects that service. Always set dedup_key so a retrying automation updates one incident instead of paging over and over.

PagerDuty: Update Alert

Resolve a single alert, or move it to a different parent incident. Resolving the last open alert on an incident resolves the incident too. Moving an alert is how a mis-grouped page gets untangled, and it is the closest thing PagerDuty has to un-merging. Reversible: set the status back, or move the alert again.

PagerDuty: Update Escalation Policy

Change an escalation policy. escalation_rules REPLACES the whole ordered list, so read the current state with Get Escalation Policy and send the full set, or you will silently remove levels. Changing who a rule targets changes who gets paged for every service on this policy, which is worth confirming before automating. Reversible by writing the previous rules back.

PagerDuty: Update Schedule

Change a schedule: rename it, move its time zone, or replace its rotation layers. schedule_layers REPLACES the layer list, so read the current state with Get Schedule and send the full set. Changing a live rotation changes who is on call right now, so it is worth previewing the result before writing. Reversible by writing the previous layers back.

PagerDuty: Update Service

Change a service: rename it, repoint it at a different escalation policy, change its urgency rules, or set status to disabled so it stops creating incidents. Reversible by writing the previous values back, so read the current state with Get Service first. Note that repointing the escalation policy changes who gets paged for everything on this service.

PagerDuty: Update User

Change someone's name, email, role, job title or time zone. Two of these have teeth: changing the ROLE can remove their ability to acknowledge incidents, and changing the TIME ZONE shifts how their schedule restrictions are interpreted. Reversible by writing the previous values back, so read Get User first.

Connecting PagerDuty takes one credential

There are two credentials here and they are genuinely different things. The REST API key authenticates 48 of the 50 nodes: it is created in PagerDuty under Integrations, then API Access Keys, and Mattering sends it as an Authorization header in PagerDuty's own format, the literal word Token followed by token=your-key, which is not Bearer. Keys are region-local, so the credential carries a service region field of us or eu and Mattering addresses api.pagerduty.com or api.eu.pagerduty.com accordingly. The two Events API nodes take no Authorization header at all: they carry a routing key in the request body, which is the Integration Key of an Events API v2 integration on one specific service. That key is not an account credential, it is the routing decision, because it selects the service the event lands on and therefore who gets paged.

1

In PagerDuty, open Integrations, then API Access Keys, and create a key. An account-level key names no person, which is why the write nodes ask for a From email; a user-level key inherits that user's permissions.

2

In Mattering Automations, open Connectors, click Add Connector, choose PagerDuty, and create a credential. Paste the key into REST API Key, set Service Region to us or eu to match the region your key belongs to, and put an email address of a real user on the account into From Email.

3

If you plan to use the Events API nodes, add a Default Events Routing Key as well. It is the Integration Key from an Events API v2 integration on a service you own. Storing it on the connection keeps it out of node configuration, where anyone who can see the automation can read it.

4

Click Test Connection. Mattering calls the abilities endpoint, the cheapest authenticated read in the API: a short list of feature names proves the credential, and a 401 means the key is wrong, revoked, or lacks the access the read needs.

5

All 50 PagerDuty nodes appear in the canvas palette. Run PagerDuty: List Abilities first to see which account features exist, then PagerDuty: List Services for the service IDs that most other nodes ask for.

Common uses for the PagerDuty MCP

Route a message to whoever is actually on call

PagerDuty: List On Calls with no date range answers who is on call right now, pairing each person with the schedule and escalation policy that put them there and at which level. That single read is the most useful thing in this connector: a workflow can look up the right human and send them a Mattering Comms message, assign them a Productivity task, or add them to a thread, instead of broadcasting to a channel and hoping. It is a read, so nobody is paged by it. PagerDuty applies its own operation specific limit to this endpoint on top of the global one, so a workflow that wants a live answer should ask when it needs one rather than polling in a tight loop.

An incident brief an agent can assemble without touching anything

PagerDuty: Get Incident returns the full object, PagerDuty: List Incident Alerts returns the machine payload the monitoring tool actually sent, PagerDuty: List Incident Log Entries returns the whole timeline of who was notified and who answered, and PagerDuty: List Incident Notes returns the human commentary. All four are safe reads, which makes them the natural surface to hand an AI agent: it can summarise what happened and what has already been tried, and write the summary somewhere a person will see it, without the ability to change the incident.

Write back what the automation did

PagerDuty: Add Incident Note puts a line in the incident timeline attributed to the person in the From email, and adding a note pages nobody. It is the polite way for a workflow to say which runbook it ran, what it found, and what a human still needs to do. When the automation has genuinely fixed the thing, PagerDuty: Manage Incident sets the status to acknowledged to stop the escalation clock or to resolved to close it out. Worth knowing before automating it: setting a resolved incident back to triggered reopens it, and reopening notifies again.

Close the loop on an event your own systems raised

PagerDuty: Trigger Event opens an alert and an incident through the Events API using a routing key, and PagerDuty: Acknowledge or Resolve Event closes it using the same routing key and the de-duplication key the trigger was sent with. That pair is the self-healing pattern: the workflow pages, fixes, and resolves. Say the cost plainly rather than calling it instant alerting. The trigger is flagged destructive because it makes a phone ring, so keep it behind a real condition, always set a dedup key so a retrying workflow updates one incident instead of paging repeatedly, and never point a test run at a production routing key.

Rota changes that do not need a human in the web app

PagerDuty: Create Schedule Override puts a named person on call for a specific window on top of whatever the rotation says, which is the node behind sick days, holidays and follow-the-sun handovers. PagerDuty: List Schedule Overrides shows what is already in place, with since and until both required, and PagerDuty: Delete Schedule Override hands the window back while it is still in the future. The one thing an automation cannot do is tell the person: whoever the override names will be paged for anything that arrives in that window, so pair the write with a message to them.

On-call load reporting that lands in a database

PagerDuty: Get Incident Metrics returns counts, escalations, notifications, interruptions split by business, off and sleep hours, and the mean times to acknowledge, engage, mobilize and resolve. PagerDuty: Get Service Metrics gives the same broken down per service with an uptime percentage, which is the read behind a service scorecard: which service pages people most and which one wakes them at night. Both accept a date range and an aggregate unit of day, week or month, and both are reads despite being POST requests. Three caveats worth knowing before you build on them: PagerDuty's analytics pipeline runs behind live, generally within 24 hours, so the most recent bucket may still be filling in; a user-level or OAuth key must supply a team or service filter where an account-level key need not; and PagerDuty's aggregated analytics endpoints declare the analytics.write scope even though they are reads, so an OAuth app granted only read scopes is refused.

Example: A monitoring alert becomes a routed message, and only pages when it should

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: an inbound webhook from your monitoring tool fires, carrying a service name and a severity.

2

PagerDuty: List Services resolves the service name to the service ID that the rest of the workflow needs.

3

A condition splits on severity. Anything below your paging threshold takes the quiet path and never reaches an Events node.

4

PagerDuty: List On Calls returns the person currently on call for that service, with the escalation policy and level that put them there.

5

On the quiet path, the workflow sends that person a Mattering Comms message with the detail and opens a Mattering Productivity task, so it is on somebody's list without anybody's phone ringing.

6

On the paging path only, PagerDuty: Trigger Event raises the incident with a dedup key derived from the alert, so retries update one incident rather than paging over and over.

7

PagerDuty: Add Incident Note writes the runbook link and the workflow run ID into the incident timeline, so the responder opens the page already knowing what the automation saw.

PagerDuty MCP questions, answered

What PagerDuty operations are supported?

50 nodes, 24 query and 26 action, across twelve families: account abilities and priorities, incidents (list, get, create, manage, merge, snooze, alerts, alert update, log entries, notes list and note create), the Events API v2 trigger and acknowledge or resolve, services, escalation policies, schedules with overrides, the on-call read, users, teams and team members, account-wide log entries, maintenance windows, and the two Analytics metric reads. Deliberately not included yet: webhook subscriptions, Event Orchestrations, business services, automation actions, incident workflows, status pages, custom fields, change events, audit records, and per-user contact methods and notification rules. Rulesets and service event rules are excluded on purpose, because PagerDuty's own documentation carries an end-of-life notice recommending Event Orchestration instead.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. The 24 read nodes are the sensible surface to hand an assistant first; the writes are there when you want them, with the seven destructive ones flagged.

Is there an official PagerDuty MCP server, and why use this one?

Yes. PagerDuty publishes its own MCP server, offered as a hosted remote service and as a self-hosted local server, read-only by default, and it is a good answer to the question of letting an assistant look things up. This connector answers a different question. These nodes run on the Mattering canvas inside scheduled and triggered automations, alongside every other connector, so a PagerDuty read can feed a Comms message, a Productivity task, or a database row in the same run, and the write nodes are available with a destructive flag rather than absent. If all you want is an assistant that can read your incidents, the vendor server is the shorter path.

Why are there two different credentials?

Because PagerDuty has two APIs with two authentication models. The REST API takes an API key in an Authorization header, in PagerDuty's own format, the literal word Token followed by token=your-key, rather than Bearer, and that key is what 48 of the 50 nodes use. The Events API v2 takes no Authorization header at all: the request body carries a routing key, which is the Integration Key of one Events API v2 integration on one service. That key is per-integration rather than per-account and it decides which service the event lands on, so it cannot be the connection's single secret. The connector stores an optional default routing key on the connection for the common single-integration case, and the two Events nodes also accept one per node. Separately, nine write nodes ask for a From email, because PagerDuty attributes writes to a person and an account-level API key names nobody: the connection's From Email is the fallback, and without an email from one source or the other those requests fail.

Does this work with PagerDuty's EU service region?

Yes. PagerDuty runs separate US and EU service regions and keys are region-local, so the credential carries a service region field and Mattering addresses api.pagerduty.com or api.eu.pagerduty.com for REST and the matching events host for the Events API. Set it to eu if your account is in the EU region. PagerDuty will forward a US-region request when it detects an EU key rather than rejecting it outright, which means the failure mode of getting this wrong is slower and less reliable behaviour rather than a clean error, so it is worth setting deliberately.

Can an AI agent page someone by accident?

That is exactly the risk this connector is designed around. Two nodes cause a page: PagerDuty: Create Incident on the REST API and PagerDuty: Trigger Event on the Events API. Both are classed destructive even though neither deletes anything, because the side effect leaves the system and cannot be recalled. The classification is what keeps them out of unattended test runs, and their descriptions say so in plain words. The practical pattern is to give an agent the read nodes freely, keep both paging nodes behind a condition or a human approval step, and set a dedup key on every trigger so a retry loop cannot turn one problem into twenty pages. Two more nodes deserve the same caution for the opposite reason: PagerDuty: Snooze Incident silences an incident, so an automation that snoozes on a loop hides a real problem, and PagerDuty: Create Maintenance Window stops incidents being created for the named services entirely while it runs.

What are PagerDuty's API rate limits?

PagerDuty's published OpenAPI specification declares 429 responses for the REST API and marks three operations as carrying their own operation specific limit on top of the global one: bulk incident management, incident creation, and the on-calls read. It does not put numbers in the specification, so this page will not invent any; PagerDuty's rate limits documentation is the place to read the current figures. The practical note is that the on-calls read is the one automations hit first, because who is on call right now is the thing everyone wants to poll. Ask for it when a workflow needs it rather than on a timer, and when a call is refused the node reports the error on its output instead of retrying silently.

Do I need a particular PagerDuty plan?

Plan names and what sits behind them change, so check PagerDuty's current pricing page for what each plan includes rather than trusting a claim on this page. PagerDuty does publish a free plan, and it includes API calls, so most of this connector works on it: it covers up to five users, one on-call schedule and one escalation policy, which is enough for the on-call, incident, schedule and Events nodes and not enough for the two Analytics nodes, because Insights reports are available on Professional, Business, Digital Operations (legacy) and Enterprise for Incident Management and not on the free plan. A free trial of the paid plans is offered as well. Several capabilities are exposed as account abilities, among them teams, urgencies, read only users and service support hours, and that is not an alternative to plan tiers: PagerDuty's own documentation says an ability may be available to your account based on things like your pricing plan or account state, so an ability is how a plan entitlement shows up at the API rather than something separate from it. PagerDuty: List Abilities is the authoritative runtime check for which of them your account has, which is why it is both the credential health check and a sensible first step in a workflow that depends on a feature. Creating an API Access Key also requires the right permission in PagerDuty, so an account owner or admin may need to make it for you.

50 nodes waiting on the canvas

Put PagerDuty to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. PagerDuty is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products