Menu

Mattering Automations PagerDuty integration

Connect PagerDuty to Mattering Automations: on-call lookups, incident reads and writes, alerts, notes, schedules and overrides, escalation policies, services, users, teams, maintenance windows, the Events API v2, and incident analytics as workflow steps, authenticated with a region-matched API key.

The Mattering Automations PagerDuty integration adds PagerDuty's REST API and Events API v2 to your automation canvas: read who is on call right now, list and inspect incidents with their alerts, timelines and notes, acknowledge, resolve, merge or snooze them, write notes back into the incident timeline, manage schedules and overrides, escalation policies, services, users, teams and maintenance windows, trigger and resolve events through the Events API, and pull incident and per-service metrics over a date range.

There are two credentials, and the difference matters more here than in most integrations. The REST API key authenticates 48 of the 50 nodes and is sent in PagerDuty's own Authorization header format, which is not Bearer. Keys are local to a service region, so the credential carries a region field and Mattering addresses the US or EU host to match. The Events API v2 takes no Authorization header at all: it carries a routing key in the request body, and that routing key is the Integration Key of one integration on one service, which means it is not an account credential so much as the routing decision itself. Setup takes a few minutes, and this guide walks through each step and ends with the full node reference.

Because this is a paging product, the safety modeling is stated on the nodes rather than buried. Of the 50 nodes, 24 read and 26 act, and seven are flagged destructive: the deletes for services, escalation policies, schedules, users and teams, plus incident creation and event triggering. 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 further nodes carry warnings without the flag, because their effect is to stop people being told: snoozing an incident, and opening a maintenance window that suppresses alerting for the named services while it runs.

Before you start

  • A PagerDuty account where you can create an API Access Key, under Integrations, then API Access Keys. Creating one needs the right permission in PagerDuty, so an account owner or admin may have to make it for you.
  • Knowing which service region your account is in. PagerDuty runs separate US and EU regions and keys are local to one of them, so you will need to set this on the credential.
  • The email address of a real user on the account. Nine write nodes send PagerDuty's From header so the write is attributed to a person, and the connection-level From Email is the fallback for all of them.
  • Only if you plan to use the two Events API nodes: the Integration Key of an Events API v2 integration on a service you own. It is found on that service's integration detail page, not in the API keys screen.
  • A Mattering workspace with access to the Automations app.
  • Not part of this integration: PagerDuty webhook subscriptions, Event Orchestrations, business services, automation actions, incident workflows and status pages. Nothing here listens for PagerDuty events, so workflows start from a Mattering trigger, a schedule, or another connector.

Get your PagerDuty API key

Mattering authenticates REST requests with a PagerDuty API Access Key, sent as an Authorization header in PagerDuty's own format: the literal word Token, then token=your-key. It is not a Bearer token, and pasting it into a generic bearer credential elsewhere will not work. Mattering also sends PagerDuty's versioned Accept header on every REST request for you, so there is nothing to configure for that. The Events API nodes are the exception to all of this and are covered at the end of this section.

Sign in to PagerDuty and open Integrations, then API Access Keys.
Click Create New API Key, give it a description that says it is for Mattering, and choose whether it is account-level or user-level.
An account-level key has full access to the account and names no person, which is exactly why the write nodes ask for a From email. A user-level key inherits that user's permissions instead. One consequence to know before you build reports: the Analytics endpoints require a team or service filter for user-level keys, while an account-level key needs no filter.
Copy the key before you leave the page and store it somewhere built to hold secrets. PagerDuty shows the key in full exactly once and says so plainly: store your key in a secure location, this is the only time it is displayed in full. An account-level key can read and change everything the account owns, including who gets paged. If the key is ever lost or exposed, create a new one and remove the old one in PagerDuty rather than leaving it live.
Note which service region your account is in. Keys belong to one service region, and PagerDuty says it can forward requests from the US to the EU when it detects an EU key, so a mismatch is more likely to cost you latency and reliability than to fail outright.
Only for the Events API nodes: open the service you want to be able to page, find its Events API v2 integration, and copy the Integration Key. That value is the routing key.
The routing key is not just a secret, it is the routing decision. It selects which service an event lands on and therefore which humans get paged. Never use a production service's routing key while testing, and prefer storing it as the connection's default rather than typing it into node configuration, where anyone who can open the automation can read it.

Connect PagerDuty to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose PagerDuty from the list.
Click Create new credential, paste the key into REST API Key, and fill in the other fields before saving.
Set Service Region to us or eu to match the region your key belongs to. Leaving it blank means US.
Getting the region wrong does not usually produce a clean error. PagerDuty will forward a US-region request when it detects an EU key, so the symptom is slower and less reliable behaviour rather than a refusal, which is why it is worth setting deliberately rather than discovering later.
Put a real user's email address into From Email. PagerDuty attributes writes to a person, so this is what appears in the incident timeline when an automation acknowledges an incident or adds a note. Individual nodes can override it.
If you will use the Events API nodes, paste the Integration Key into Default Events Routing Key. Leave it blank if you will not, since the two Events nodes are the only things that read it and an events-only connection does not need a REST key either.
Both the API key and the routing key are stored encrypted in Google Secret Manager and are redacted from workflow logs.
Click Test Connection. Mattering calls PagerDuty's abilities endpoint on the host for your chosen region: it is the cheapest authenticated read in the API, it takes no parameters, and a short list of feature names proves the credential.
Click Connect. All 50 PagerDuty nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette for a PagerDuty section listing the query and action nodes. Drop PagerDuty: List Abilities onto the canvas and run a test step. It is the natural probe: no parameters, no paging, and it returns the account features that several other nodes depend on, among them teams, urgencies, read only users and service support hours. If a feature you were expecting is missing from that list, the nodes that rely on it will behave differently and that is an account setting rather than an integration fault.

Next run PagerDuty: List Services and copy a service ID, because the incident, maintenance window and metrics nodes all ask for one. Then run PagerDuty: List On Calls with no date range: it answers who is on call right now and pairs each person with the schedule and escalation policy that put them there, which is the read most workflows are built around. PagerDuty: List Users completes the picture, and its email column is what the From header on every write node wants.

One thing not to do: never verify this integration by running PagerDuty: Trigger Event or PagerDuty: Create Incident. Both open a real incident and page whoever is on call for the service, on their phone, and resolving afterwards does not undo that. Everything in the verify path above is read-only, reaches none of the seven destructive nodes and pages nobody, so it is safe to re-run whenever you rotate the key or change the region.

Node reference

50 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 24

PagerDuty: Get Escalation Policy

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

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

pagerduty_get_analytics_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

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

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

pagerduty_get_analytics_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

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

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

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

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

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

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

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

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

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

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

pagerduty_list_oncalls

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

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

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

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

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

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

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

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

pagerduty_manage_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

pagerduty_create_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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pagerduty_update_incident_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

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

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

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

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.

Using the integration

On the automation canvas

PagerDuty nodes chain with every other node on the platform. A scheduled workflow can run PagerDuty: List On Calls and post the current rotation into a Mattering Comms channel each morning, an incident webhook from your own systems can read PagerDuty: List Incidents to check whether the problem is already known before raising anything, and a nightly sweep can write PagerDuty: Get Service Metrics output into a Mattering database so on-call load is tracked next to the rest of the work. The service ID from PagerDuty: List Services and the incident ID from PagerDuty: List Incidents are the two values most downstream nodes ask for.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can drive the same surface. The 24 read nodes are the right first grant: an assistant can assemble a full incident brief from PagerDuty: Get Incident, PagerDuty: List Incident Alerts, PagerDuty: List Incident Log Entries and PagerDuty: List Incident Notes without being able to change anything. PagerDuty also publishes its own MCP server, read-only by default, which is a good answer if lookups from a chat client are all you want. This integration is the other shape: the same operations running inside scheduled and triggered automations alongside every other connector, with the writes available and the dangerous ones flagged.

The on-call lookup, and what to do with it

PagerDuty: List On Calls is the most useful read in the integration. With no date range it answers who is on call right now, at which escalation level, under which policy, and it can be narrowed by schedule, policy or user. Setting earliest to true returns only the earliest on call for each combination of escalation policy, escalation level and user, so it thins the result rather than collapsing it to one row. Put it in front of a message and the right person gets pinged rather than a whole channel; put it in front of a task assignment and the work lands on whoever is actually carrying the pager. Two practical notes: PagerDuty computes on-call shifts 90 days into the future, so this is a now-and-soon read rather than a long-range planner, and PagerDuty applies its own operation specific limit to this endpoint on top of the global one, so ask when a workflow needs an answer instead of polling on a short timer.

Read the incident before writing to it

PagerDuty: Get Incident returns far more than a row from the lister, including assignees, acknowledgements, alert counts and whether the incident can be merged. PagerDuty: List Incident Alerts is where the actual monitoring payload lives, since the incident is the human-facing wrapper and the alert body carries the machine data the sending tool attached. PagerDuty: List Incident Log Entries is the timeline of every notification, acknowledgement, escalation and reassignment, which is how an automation finds out what has already been tried before it acts. PagerDuty: List Incident Notes carries the human commentary, which is usually the best thing to summarise into a chat message.

Writing back without paging anyone

PagerDuty: Add Incident Note appends to the incident timeline attributed to the From email and pages nobody, so it is the safest write in the integration and the right way for a workflow to record which runbook it ran and what a human still needs to do. PagerDuty: Manage Incident acknowledges, resolves, reassigns, re-prioritises or escalates one incident, and acknowledging is what stops the escalation clock. Read the direction carefully before automating it: setting a resolved incident back to triggered reopens it, and reopening notifies again. PagerDuty: Merge Incidents folds several incidents into one, but the source incidents are resolved by the merge, so it is not a clean undo even though an alert can be moved back out with PagerDuty: Update Alert. PagerDuty: Snooze Incident buys quiet for a fixed number of seconds, and the honest framing is that nobody is being told about the incident during that time, so a workflow that snoozes on a loop is hiding a problem rather than handling it.

The Events API, and the two nodes that page a human

PagerDuty: Trigger Event and PagerDuty: Acknowledge or Resolve Event are the only nodes that use the routing key instead of the REST API key, because the Events API takes no Authorization header at all. Together they are the self-healing pattern: the workflow raises the page, does the work, and resolves using the same de-duplication key it triggered with. The trigger is flagged destructive, and the reason is not reversibility, it is that a real person's phone rings. Always set a dedup key so a retrying workflow updates one incident rather than paging repeatedly, keep the trigger behind a genuine condition or an approval step, and point test runs at a service nobody is on call for. PagerDuty: Create Incident on the REST API is flagged for the same reason: it pages the same people through the same escalation policy, so treating one as safe and the other as dangerous would be a line a tester crosses by accident.

Send whole objects when you update a schedule or an escalation policy

Two write nodes have a shape worth knowing before an automation touches them. PagerDuty: Update Escalation Policy takes the ordered rule list as a whole, and PagerDuty does not document it as a partial update, so read the current state with PagerDuty: Get Escalation Policy and send the full set rather than the single level you meant to change. PagerDuty: Update Schedule and its rotation layers are the same story, so pair it with PagerDuty: Get Schedule. That is connector guidance rather than vendor-documented behaviour, and it costs one extra read to stop caring which way it falls. Both changes decide who gets paged for every service attached, which makes them worth a preview or an approval step. For the everyday case, do not rewrite the rota at all: PagerDuty: Create Schedule Override puts one named person on call for one window on top of whatever the rotation says, 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. Whoever an override names will be paged for anything that arrives in that window, so send them a message in the same run.

Maintenance windows suppress paging, which is the point and the hazard

PagerDuty: Create Maintenance Window stops incidents being created for the named services for its duration, which is exactly what a planned deploy wants and exactly what makes a forgotten window dangerous: a real outage starting inside it is invisible until it ends. Keep windows short, name the services precisely, and prefer ending one early with PagerDuty: Delete Maintenance Window over opening a wide one. That delete is classed as a reversible write rather than destructive because its effect is to turn paging back on. During an incident, PagerDuty: List Maintenance Windows filtered to ongoing answers the question nobody thinks to ask: is this service quiet because nothing is wrong, or because somebody suppressed it?

The seven destructive nodes, gated

PagerDuty: Create Incident and PagerDuty: Trigger Event are flagged because they page people. The other five destroy configuration that paging depends on. PagerDuty: Delete Schedule is the worst of them: PagerDuty's API documentation states no guard rail for it, so an escalation policy that targeted the schedule can be left with a level that has nobody behind it, and paging for every service on that policy breaks silently and at the worst possible moment. Check what points at a schedule before you delete it rather than relying on PagerDuty to refuse. PagerDuty: Delete Escalation Policy is refused while any service still uses it, which is a real guard rail worth respecting rather than working around by repointing the service at some other policy first. PagerDuty: Delete Service stops any new incidents being created for it, so monitoring tools still sending to its routing keys page nobody at all. PagerDuty: Delete User removes that person from every schedule layer and escalation rule that named them, leaving a rotation that looks configured with a hole in it. PagerDuty: Delete Team moves unresolved incidents to a reassignment team if you name one and otherwise makes them account-level, which widens who can see them. The pattern for all five is the same: read the thing first, check what references it, and put the delete behind an approval step rather than a bare trigger.

Troubleshooting

Test Connection fails with a 401 error
PagerDuty returns 401 when the Authorization header does not carry a valid key for the host being called, so there are three usual causes. First, the key itself: check for whitespace picked up in the copy, and confirm it was not removed or replaced in API Access Keys after you saved it. Second, the region, though this one is rarely the cause of a 401: keys belong to one service region, and PagerDuty says it can forward REST and Events requests from the US to the EU when it detects an EU key, so a mismatch shows up as slower and less reliable behaviour far more often than as a clean refusal. Open the credential and check that Service Region matches where the account lives anyway, because a forwarded request is not the request you want inside a workflow. Third, the wrong kind of value: an Events API v2 Integration Key is not a REST key and will never authenticate here, so if the value came from a service's integration page rather than from Integrations, then API Access Keys, that is the problem.
A write node fails saying no From email is set
Nine nodes send PagerDuty's From header: PagerDuty: Create Incident, PagerDuty: Manage Incident, PagerDuty: Add Incident Note, PagerDuty: Snooze Incident, PagerDuty: Merge Incidents, PagerDuty: Update Alert, PagerDuty: Create Escalation Policy, PagerDuty: Create User and PagerDuty: Create Maintenance Window. PagerDuty requires it because it attributes the write to a person and an account-level API key names nobody, so the acknowledgement or the note shows up in the timeline as having been done by someone. The field is deliberately not marked required on the node, because the connection's From Email is meant to cover it. Fix it in one of two places: set From Email on the credential, or fill the node's own from email field for a one-off. PagerDuty also rejects an address that does not belong to a user on the account, so use one from PagerDuty: List Users.
Trigger Event returns success but nobody was paged
The Events API answers 202 with a status of success once it has accepted the event, which is an acknowledgement of receipt rather than a promise that somebody's phone rang, so a clean response and a silent rotation is a normal combination to have to debug. Check the routing key first: it decides which service the event lands on, so a key from the wrong service pages the wrong rotation or one that is empty. Check whether that service has an active maintenance window with PagerDuty: List Maintenance Windows filtered to ongoing, since a window suppresses incident creation entirely. Then check de-duplication: if the dedup key matches an alert that is already open, PagerDuty updates that alert instead of raising a new page, which is the behaviour you want from a retry loop and a surprise the first time you meet it. PagerDuty: List Incident Alerts on the existing incident shows whether that is what happened.
Acknowledge or Resolve Event is accepted but the incident stays open
PagerDuty: Acknowledge or Resolve Event matches on the de-duplication key, and a resolve sent for a key with no open alert behind it is still accepted, so a clean 202 is not evidence that anything was closed. Confirm the dedup key is exactly the one the trigger used, including case, and confirm the routing key is the same integration, since a dedup key is only meaningful within the service it was raised against. The other thing to know is what resolves what: resolving the last open alert on an incident resolves the incident, but an incident with several alerts stays open until they are all closed. When the incident was not raised through the Events API in the first place, this node is the wrong tool and PagerDuty: Manage Incident is the right one.
The Analytics nodes return an error or nothing useful
Four separate causes, in the order worth checking. Key scope: PagerDuty: Get Incident Metrics and PagerDuty: Get Service Metrics require a team or service filter when called with a user-level or OAuth key, while an account-level key needs none, so an unfiltered call on a personal key fails by design. OAuth scope: these aggregated endpoints declare the analytics.write scope even though they are reads and are POST requests only because the filters travel in the body, so an OAuth app that was granted read scopes alone is refused. Data lag: PagerDuty's analytics pipeline runs behind live, generally within about a day, so the most recent bucket may still be filling in and a workflow reading today's numbers will see them change. Availability: these endpoints depend on PagerDuty's Insights reports, which are available on the Professional, Business, Digital Operations (legacy) and Enterprise for Incident Management plans and not on the free plan, so check the account's plan before building a report on them. Also note the range limit, one year at most between the start and end of the window, and that leaving the aggregate unit blank returns a single undated row for the whole period rather than a time series.
List Schedule Overrides rejects the request
This lister requires both since and until, which is unusual for this API and is the most common cause of a rejected call. Supply an explicit range rather than relying on defaults. Two related behaviours to expect: set editable to true to get only future overrides, which is what you need before calling PagerDuty: Delete Schedule Override, because a past override cannot be removed at all, and an override that is currently running is truncated to now rather than deleted, which PagerDuty signals by answering 200 instead of 204. If a delete looks like it did not happen, that difference in status code is usually the explanation.
A delete is refused because something still depends on the object
Several PagerDuty deletes are guarded, and the refusals are protecting paging rather than being awkward. PagerDuty: Delete Escalation Policy is refused while any service still uses the policy, so run PagerDuty: List Services and check which ones point at it. PagerDuty: Delete Team is refused while the team still owns escalation policies, services, schedules or subteams. PagerDuty: Delete User is refused while that person still has assigned incidents, unless your pricing plan has PagerDuty's offboarding feature, which is itself plan-gated, in which case reassignment happens asynchronously and may not have finished when the call returns. In each case the fix is to resolve or move what the object owns first, and to treat the refusal as a prompt to check what breaks rather than an obstacle to route around.
Requests start failing with 429 responses
PagerDuty rate limits its REST API and answers 429 when a limit is reached, and three operations carry their own operation specific limit on top of the global one: bulk incident management, incident creation, and the on-calls read. PagerDuty: List On Calls is the one automations meet first, because current on-call status is the thing everybody wants to poll. This page states no numbers because the API specification does not carry them; PagerDuty's rate limits documentation is where to read the current figures. Practically: read on-call status when a workflow actually needs it rather than on a short timer, cache the answer for the length of a run, and prefer one filtered PagerDuty: List Incidents call over many single PagerDuty: Get Incident calls in a loop. The nodes report the error on their output rather than retrying silently, so a workflow can wait and continue.
A node reports a feature is not available on this account
Several PagerDuty capabilities are exposed as account abilities, among them teams, urgencies, read only users and service support hours, and a node that depends on a missing one fails or returns an empty result. Abilities are 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. Run PagerDuty: List Abilities for the authoritative runtime answer on which features the account has: it is the same read that Test Connection uses, and it takes no parameters. For what each plan includes, check PagerDuty's current pricing page. Two specific cases show up most. Every team-scoped filter needs the teams ability, so run PagerDuty: List Teams early on an account where you are not sure teams are enabled. And PagerDuty: List Priorities may return no priorities on an account that has not configured them, which then makes any priority ID a downstream node wants impossible to supply. Checking abilities at the start of a workflow that depends on one is cheaper than debugging the failure later.

PagerDuty is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products