> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rootly.com/llms.txt
> Use this file to discover all available pages before exploring further.

# PagerTree

> Connect PagerTree to Rootly for inbound alert webhooks, outbound paging, linked incident workflows, and automatic alert synchronization.

## Introduction

The PagerTree integration connects Rootly with PagerTree so teams can receive alert activity in Rootly and page responders from Rootly when incidents need escalation.

This integration is a good fit for teams that already use PagerTree for alerting or paging and want Rootly to act as the central place for incident coordination and workflow automation.

With the PagerTree integration, you can:

* Receive PagerTree alert activity in Rootly through outgoing webhooks
* Create and update Rootly alerts from PagerTree events
* Page PagerTree teams and users from Rootly
* Create PagerTree alerts from incident workflows
* Automatically resolve linked PagerTree alerts when Rootly incidents are resolved

## Before You Begin

Before installing the integration, make sure you have:

* A Rootly account with permission to manage integrations
* A PagerTree account with permission to create API keys
* Access to create an **Outgoing Webhook** integration in PagerTree
* The teams or users in PagerTree that you want Rootly to page

<Note>
  Rootly uses two separate credentials for this integration:

  * The **PagerTree API key** is used for Rootly-to-PagerTree API requests
  * The **Rootly webhook secret** is used when PagerTree sends webhook events into Rootly
</Note>

## Install the PagerTree Integration in Rootly

<Steps>
  <Step title="Add the PagerTree integration in Rootly" icon="plug">
    Open the integrations page in Rootly and choose **PagerTree**.

    From there, enter your PagerTree API key and save the integration.

    Rootly uses this API key to communicate with the PagerTree API for paging, alert creation, and alert updates.
  </Step>

  <Step title="Copy the webhook details from Rootly" icon="copy">
    After saving the integration, Rootly provides the webhook details you will need in PagerTree.

    You will use these values when configuring the PagerTree outgoing webhook:

    * The Rootly webhook URL
    * The Rootly webhook secret
  </Step>
</Steps>

## Configure PagerTree Outgoing Webhooks

PagerTree sends alert events to Rootly using an outgoing webhook. Rootly expects the standard PagerTree webhook payload and the correct Rootly webhook secret.

<Steps>
  <Step title="Create an Outgoing Webhook integration in PagerTree" icon="webhook">
    In PagerTree, create a new **Outgoing Webhook** integration.

    PagerTree’s outgoing webhook documentation is available here:

    [PagerTree Outgoing Webhook Guide](https://pagertree.com/docs/integration-guides/outgoing-webhook)
  </Step>

  <Step title="Use the Rootly webhook URL and secret" icon="key">
    Configure the outgoing webhook in PagerTree using the webhook URL provided by Rootly.

    Rootly typically expects the webhook secret to be included with the request, often as a `?secret=` query parameter on the webhook URL, unless the Rootly UI shows a different format for your workspace.

    If the secret does not match, Rootly rejects the request.
  </Step>

  <Step title="Keep the default PagerTree payload format" icon="code">
    Rootly expects the standard PagerTree outgoing webhook structure:

    ```json theme={null}
    {
      "type": "alert.created",
      "data": { ... }
    }
    ```

    If you customize the PagerTree webhook template, make sure it still includes the fields Rootly needs, especially:

    * `type`
    * `data`
    * Alert identifiers such as `id` and `sid`
    * Alert details such as `title`, `description`, `status`, and `urgency`
  </Step>
</Steps>

## Supported PagerTree Events

Rootly supports the following PagerTree webhook events:

* `alert.created`
* `alert.open`
* `alert.acknowledged`
* `alert.rejected`
* `alert.timeout`
* `alert.resolved`
* `alert.dropped`
* `alert.handoff`

These events can create or update Rootly alerts and, when linked to a Rootly incident, may also add incident activity in Rootly.

## How PagerTree Events Appear in Rootly

When PagerTree sends a supported webhook event to Rootly, Rootly stores and processes that event as PagerTree alert activity.

In most cases, Rootly uses the PagerTree alert data to create or update a Rootly alert with:

* The PagerTree alert ID as the external reference
* The alert title or description as the Rootly summary
* PagerTree status and urgency as labels
* A PagerTree alert URL for reference

If a PagerTree event is already associated with a synced Rootly incident, Rootly may skip creating a duplicate alert and instead add incident activity where appropriate.

## Severity and Urgency Mapping

When Rootly creates or updates PagerTree alerts via workflows, it maps Rootly incident severity to PagerTree severity levels:

| Rootly Severity | PagerTree Severity |
| --------------- | ------------------ |
| Critical        | SEV-1              |
| High            | SEV-2              |
| Medium          | SEV-3              |
| Low             | SEV-4              |

You can also set urgency explicitly when configuring a workflow action. Supported urgency values are `critical`, `high`, `medium`, `low`, and `auto` (lets PagerTree decide based on its own rules).

## Page PagerTree from Rootly

Rootly can also page PagerTree teams or users when incidents require escalation.

This is commonly used when:

* A Rootly incident needs to notify a PagerTree team
* A Slack-driven incident flow needs to escalate into PagerTree
* An incident workflow should automatically create a PagerTree alert

Rootly sends these requests to PagerTree using your configured API key.

## Default Workflows

When the PagerTree integration is connected, Rootly can create default workflows to support common PagerTree actions.

These workflows typically include:

* Creating a PagerTree alert when a Rootly incident is created
* Automatically resolving a linked PagerTree alert when the Rootly incident is resolved

After installation, review these workflows to make sure they match your team’s escalation process.

## Troubleshooting

<AccordionGroup>
  <Accordion title="PagerTree says the webhook is failing" icon="triangle-exclamation">
    This usually means Rootly is not accepting the webhook request. The most common cause is an incorrect or missing Rootly webhook secret. When the secret does not match, Rootly can return an error response such as HTTP 401.
  </Accordion>

  <Accordion title="No PagerTree events are appearing in Rootly" icon="eye-slash">
    Check the PagerTree outgoing webhook rules and confirm events are actually being sent to Rootly. Custom webhook rules or ignored events in PagerTree can prevent delivery.
  </Accordion>

  <Accordion title="The alert data in Rootly looks incomplete" icon="file-circle-question">
    If you customized the PagerTree outgoing webhook payload, make sure it still includes the standard fields Rootly expects, including the event type and alert data object.
  </Accordion>

  <Accordion title="Why am I seeing duplicate or unexpected alert behavior?" icon="copy">
    PagerTree may retry failed webhook deliveries, and according to PagerTree’s webhook documentation those retries can happen multiple times. Rootly also uses PagerTree alert identifiers to determine how events should be created or updated, so retries and identifier reuse can affect how alerts appear.
  </Accordion>

  <Accordion title="Why did alerts stop appearing after working before?" icon="circle-exclamation">
    If webhook delivery is succeeding but new alerts are no longer being created, check whether your Rootly workspace has reached its alert limits. Incoming PagerTree alerts are still subject to your Rootly plan limits.
  </Accordion>
</AccordionGroup>

## Related Pages

<CardGroup cols={3}>
  <Card title="Alert Workflows" icon="bolt" href="/workflows/alert-workflows">
    Automate incident creation, notifications, and follow-up actions for alerts.
  </Card>

  <Card title="Slack Integration" icon="slack" href="/integrations/slack">
    Page and manage incidents from Slack when Slack is part of your incident workflow.
  </Card>

  <Card title="Incidents" icon="triangle-exclamation" href="/incidents">
    Learn how incidents are created, updated, and escalated in Rootly.
  </Card>
</CardGroup>