Integrations are dynamic and flexible. The integration process is simple and involves two steps:

  1. Receiving a payload
  2. Mapping payload attributes to incidents

How Integrations Work

To create a new integration, simply navigate to the Integrations tab and click on the `Create New Integration button.

From there, give your integration a name, such as “AWS Amazon CloudWatch” if you’re connecting to this tool. You’ll also need to choose which team the integration should belong to, as this can’t be changed later. Finally, select the type of integration, such as “AWS Amazon CloudWatch”. Keep in mind that the integration type can’t be changed later.

Configuring Integrations

Again, integrations work by a two-step process:

  1. Receiving a payload
  2. Mapping payload attributes to incidents

Step 2 is identical for each integration type, while step 1 (receiving the payload) differs for each integration type.

We’ll walk you through these steps by the example of a Webhook Integration.

Receiving Payloads

Once you’ve created an integration of type Webhook, you can send HTTP requests to the integration’s URL.

Every request sent to this address will show up as a new payload from which we’ll extract attributes and map these to incidents.

You can see payloads that were received by All Quiet in the right pane and select them as a template / example for your attribute mapping.

The payload will always be in JSON format and wrap other formats like HTML or XML depending on your payload.

Issue the following cURL command to send a form post to a webhook integration. The payload will show up under the field formBody.

curl -X POST
-H "Content-Type: application/x-www-form-urlencoded"
-d "alertName=My+Monitor&alertStatus=Failed&description=From+cURL"

Learn more about generic webhooks here: Connect Generic Webhooks.

Triggering Dummy Incidents

To get a practical understanding of All Quiet’s incident handling, you have the option to initiate a dummy incident. This feature allows you to simulate a real incident by using the current request payload example alongside your established mapping configurations.

When you trigger a dummy incident, the system will execute all the usual processing steps. This includes sending out notifications to your teams and managing any outgoing integrations. This simulation is an effective way to experience firsthand how All Quiet will respond in an actual operational scenario. It’s an invaluable tool for verifying that your configurations and mappings will behave as expected during a live incident.

Here’s how to trigger a dummy incident:

  1. Navigate to the Payload section, where you’ll see your saved request payload for testing.
  2. Review your Mapping settings to ensure they’re correctly configured to simulate the desired incident conditions.
  3. Click on Trigger Dummy Incident to start the simulation. You’ll observe the full cycle of incident processing as if it were a genuine alert.

Mapping Payloads

To map a payload’s JSON to an actual incident you need to define a set of mapping rules. Those rules are also defined in JSON. To allow you to conveniently configure your mapping your changes to the JSON are automatically applied to a preview of an incident.

Teams are a means of organizing collaborators (team members) and integrations.

  • Each user can be a member of multiple teams.
  • Each integration belongs to exactly one team.
  • Each incident triggered by an integration is thus available for collaboration only to the members of the integration’s team.

How does attribute mapping work?

With attribute mapping you can map the payload of your integration to the defined data structure of All Quiet’s incidents.

For each attribute in attributes we will evaluate all mappings from the first to the last element. The result of a mapping will be passed on to the next mapping element as an input. The last result will be the attribute’s value. In the following example the attribute Status is first mapped by a jsonPath and then by a map evaluation.

Let’s assume, we’ve created an integration of type Webhook. We can use the following CURL command below as an example to trigger the webhook:

curl -X POST '' \
-H 'Content-Type: application/json' \
-d '{"alertName": "My Monitor", "alertStatus": "Failed", "description": "From cURL"}'

Then, we can map the payload to an incident with this attribute mapping:

  "attributes": [
      "name": "Status",
      "mappings": [
          "jsonPath": "$.jsonBody.alertStatus"
          "map": "Failed->Open,->Resolved"
      "name": "Title",
      "mappings": [
          "jsonPath": "$.jsonBody.alertName"
      "name": "Severity",
      "mappings": [
          "static": "Critical"
      "name": "Description",
      "mappings": [
          "jsonPath": "$.jsonBody.description"

Reserved and required attributes

You can map as many attributes with any name you like. There are a few reserved and required attributes though:

PropertyDescriptionAllowed Values
CorrelationIdOptionalUse this attribute to uniquely identify and correlate your incidents. If ommitted, a hash of all attributes is used to uniquely identify the incident.
StatusRequiredOpen, Resolved
SeverityRequiredMinor, Warning, Critical
TitleOptionalDefaults to your integration’s name

Evaluation Types

Each attribute must hold exactly one of the following evaluation types:

jsonPathA JSONPath expression to map JSON (
xPathA XPath expression to map HTML or XML. ( w3schools)
regexA regular expression to extract parts of text. The regex is evaluated with the .NET/C# flavor. If groups are matched, the named group “result” is returned. If no group is named “result” the last group is returned. If no groups are found the whole match is returned. (
mapA simple map expression mapping values from A to B. The expression A->1,B->2,->3 will map the value “A” to “1” and “B” to “2” and fallback to “3” if no match is found. You can also omit the fallback. The result will then evaluate to the original value.
staticA static string. The result will always be this string.

JSONPath examples

Extract elements by property To get the value of the “Return-Path” field of the “headers” array, use ```$.headers[?(@.field==‘Return-Path’)].value“ for the following JSON:

{ "headers": [{ "field": "Return-Path", "value": "" }] }

XPath examples

Extract elements by preceding tag value To get the value of the “Server” field, i.e. the value of the td that follows a td with value “Server” use //table/tr[td='Server']/td[2] for the following HTML:


Regex examples

To get the value “my-server” after a colon followed by space use [: ](?[^: ]*)$ for the following text:

Any label here: my-server

Note the use of the named group “result”. Since it’s the only group, the naming of the group could also be ommitted.

Built-in Integrations

Receive alerts from your observability tools. We offer generic email and webhook as well as a growing number of pre-built integrations:

Propose a new integration

Didn’t find your tool here? Upvote or add your preferred integration to our roadmap, and we’re happy to ship it. 🚢