Template notifications on Grafana Labs

Manage notification templates

Fri, 03 Apr 2026 19:43:06 +0000

Manage notification templates

In contact points, you can select notification templates to customize the notification messages sent.

By default, Grafana provides a template for the notification title ({{define "default.title"}}) and a template for the notification message ({{define "default.message"}}). Both default templates display common alert details.

You can also create custom templates to customize the content and format of notification messages, which can then be applied to one or more contact points. In Grafana, a custom notification template is created within a notification template group.

This documentation provides step-by-step instructions for selecting templates in contact points, previewing templates, and creating notification template groups using the Grafana UI.

Select a notification template for a contact point

To add an existing notification template to your contact point, complete the following steps.

Click an existing contact point or create a new one.
In Optional settings, click any field that contains templates.

For example, if you are creating an email contact point integration, click Message or Subject.
Click Edit. A dialog box opens where you can select notification templates.
Click Select notification template or Enter custom message to customize a template or message
- You can select an existing notification template and preview it using the default payload.
- You can also copy the notification template and use it in the Enter custom message tab.
Click Save contact point.

You can create custom notification templates using the Enter custom message tab. For reusable and consistent notifications, a best practice is to custom notification templates as described in the following section.

Create a notification template and notification template group

Create notification templates to customize notification messages and reuse them in contact points.

In Grafana, custom notification templates ({{define "<NAME>"}}) are created within a notification template group, allowing you to test and implement multiple templates together.

Your notification template name ({{define "<NAME>"}}) must be unique. You cannot have two templates with the same name in the same notification template group or in different notification template groups. Therefore, avoid using names already defined as default templates, such as: __subject, __text_values_list, __text_alert_list, default.title and default.message.

To create a notification template in Grafana, complete the following steps.

Click Alerts & IRM -> Contact points.
Click the Notification Templates tab and then + Add notification template group.
Enter a name for the notification template group.
Write the content of the template in the content field.
Save your changes.

If {{ define }} is not included in the content, {{ define "<NOTIFICATION_TEMPLATE_NAME>" }} and {{ end }} is automatically added to the start and end.

To create a notification template group that contains more than one notification template, complete the following steps.

Click + Add notification template group.
Enter a name for the notification template group.
Write each template in the Content field, including {{ define "<NOTIFICATION_TEMPLATE_NAME>" }} and {{ end }} at the start and end of each template.
Save your changes.

For more details on how to write notification templates, refer to the template reference and examples.

Preview a notification template

Preview how your notification templates should look before using them in your contact points, helping you understand the result of the template you are creating as well as enabling you to fix any errors before saving it.

Note
Notification template preview is only for Grafana Alertmanager.

To preview your notification templates:

Navigate to Alerts&IRM -> Alerting -> Contact points -> Notification Templates.
Click + Add notification template group or edit an existing template group.
Add or update your template content.

Default data is provided and you can add or edit alert data to it as well as alert instances. You can add alert data directly in the Payload data window itself or click Select alert instances or Add custom alerts.
Optional: To add alert data from existing alert instances:

a. Click Select alert instances.

b. Hover over the alert instances to view more information on each alert instance.

c. Click Confirm to add the alert instance(s) to the payload.
Optional: To add alert data using the Alert data editor, click Add custom data:

a. Add annotations, custom labels and/or set a dashboard or a panel.

b. Toggle Firing/resolved depending on whether you want to add firing or resolved alerts to your notification.

c. Click Add alert data.

d. Click Refresh preview to see what your template content should look like and the corresponding payload data.

If there are any errors in your template, they are displayed in the Preview and you can correct them before saving.
Save your changes.

Notification template reference

Fri, 03 Apr 2026 19:43:06 +0000

Notification template reference

By default, Grafana provides predefined templates to format notification messages.

You can also customize your notifications with custom templates, which are based on the Go template language.

This documentation lists the data available for use in notification templates.

Notification Data

In notification templates, dot (.) is initialized with the following data:

Name	Type	Description
`Receiver`	string	The name of the contact point sending the notification
`Status`	string	The status is `firing` if at least one alert is firing, otherwise `resolved`.
`Alerts`	[]Alert	List of all firing and resolved alerts in this notification.
`Alerts.Firing`	[]Alert	List of all firing alerts in this notification.
`Alerts.Resolved`	[]Alert	List of all resolved alerts in this notification.
`GroupLabels`	KV	The labels that group these alerts in this notification based on the `Group by` option.
`CommonLabels`	KV	The labels common to all alerts in this notification.
`CommonAnnotations`	KV	The annotations common to all alerts in this notification.
`ExternalURL`	string	A link to Grafana, or the Alertmanager that sent this notification if using an external Alertmanager.
`GroupKey`	string	The key used to identify this alert group.
`TruncatedAlerts`	integer	The number of alerts, if any, that were truncated in the notification. Supported by Webhook and OnCall.

It’s important to remember that a single notification can group multiple alerts to reduce the number of alerts you receive. Alerts is an array that includes all the alerts in the notification.

Here’s an example that prints all available notification data from dot (.):

{{ define "custom_template" }}
  {{ .Receiver }}
  {{ .Status }}
  There are {{ len .Alerts }} alerts
  There are {{ len .Alerts.Firing }} firing alerts
  There are {{ len .Alerts.Resolved }} resolved alerts
  {{ .GroupLabels }}
  {{ .CommonLabels }}
  {{ .CommonAnnotations }}
  {{ .ExternalURL }}
{{ end }}

You can execute this template by passing the dot (.):

{{ template "custom_template" . }}

Alert

Alert contains data for an individual alert:

Name	Type	Description
`Status`	string	Firing or resolved.
`Labels`	KV	The labels associated with this alert. It includes all types of labels, but only query labels used in the alert condition.
`Annotations`	KV	The annotations for this alert.
`StartsAt`	Time	The time the alert fired
`EndsAt`	Time	Only set if the end time of an alert is known. Otherwise set to a configurable timeout period from the time since the last alert was received.
`GeneratorURL`	string	A link to Grafana, or the source of the alert if using an external alert generator.
`Fingerprint`	string	A unique string that identifies the alert.

Grafana-managed alerts include these additional properties:

Name	Type	Description
`DashboardURL`	string	A link to the Grafana Dashboard if the alert has a Dashboard UID annotation, with time range from `1h` before alert start to end (or now if firing).
`PanelURL`	string	A link to the panel if the alert has a Panel ID annotation, with time range from `1h` before alert start to end (or now if firing).
`SilenceURL`	string	A link to silence the alert.
`Values`	KV	The values of expressions used to evaluate the alert condition. Only relevant values are included.
`ValueString`	string	A string that contains the labels and value of each reduced expression in the alert.
`OrgID`	integer	The ID of the organization that owns the alert.

This example iterates over the list of firing and resolved alerts (.Alerts) in the notification and prints the data for each alert:

{{ define "custom_template" }}
{{ range .Alerts }}
  {{ .Status }}
  {{ .Labels }}
  {{ .Annotations }}
  {{ .StartsAt }}
  {{ .EndsAt }}
  {{ .GeneratorURL }}
  {{ .Fingerprint }}

  {{/* Only available for Grafana-managed alerts */}}
  {{ .DashboardURL }}
  {{ .PanelURL }}
  {{ .SilenceURL }}
  {{ .Values }}
  {{ .ValueString }}
{{ end }}
{{ end }}

You can run this template by passing the dot (.):

{{ template "custom_template" . }}

KV

KV is a set of key value pairs, where each key and value is a string.

Similarly to accessing variable properties, you can use . to retrieve the value of a value. For example:

{{ define "custom_template" }}
  {{ .CommonLabels.grafana_folder }}
{{ end }}

If a KV happens to contain numbers or bools then these are string representations of the numeric or boolean value.

Additionally, KV provides methods to sort the pairs, remove keys, and iterate over just the keys or values:

Method name	Description	Arguments	Returns
SortedPairs	Returns a sorted list of key/value pairs.		Pairs
Remove	Returns a copy of the KV with the keys removed	[]string	KV
Names	Return the names of the label names		[]string
Values	Return a list of the values		[]string

Here’s an example of using these methods:

{{ define "custom_template" }}
  {{ .CommonLabels.SortedPairs }}
  {{ .CommonLabels.Names }}
  {{ .CommonLabels.Values }}
  {{ .CommonLabels.Remove (stringSlice "grafana_folder") }}
{{ end }}

Time

Some template functions and properties return a Time object, which refers to the type Time in Go’s time package.

When accessing a Time object, you can use various Time functions in your templates as follows.

{{ define "custom_template" }}
  {{ range .Alerts }}
    {{ .StartsAt  }}
    {{ .StartsAt.Add 6000000000000  }}
    {{ .StartsAt.Add -6000000000000  }}
    {{ .StartsAt.AddDate 1 0 0  }}
    {{ .StartsAt.Year   }}/{{ .StartsAt.Month   }}/{{ .StartsAt.Day   }}
    {{ .StartsAt.Hour   }}:{{ .StartsAt.Minute   }}:{{ .StartsAt.Second   }}
    {{ .StartsAt.YearDay   }}-{{ .StartsAt.Weekday   }}
    {{ .StartsAt.Unix }} {{ .StartsAt.UnixMilli }}
  {{ end}}
{{ end }}

Functions

Functions can perform actions in templates such as transforming or formatting data.

Note that the functions provided by Go’s template language, such as index, and, printf, and len, are available, along with many others.

In addition, the following functions are also available for templating notifications:

Name	Arguments	Returns	Description
`title`	string	string	Capitalizes the first character of each word.
`toUpper`	string	string	Returns all text in uppercase.
`toLower`	string	string	Returns all text in lowercase.
`trimSpace`	string	string	Removes leading and trailing white spaces.
`match`	pattern, text	boolean	Matches the text against a regular expression pattern.
`reReplaceAll`	pattern, replacement, text	string	Replaces text matching the regular expression.
`join`	sep string, s []string	string	Concatenates the elements of s to create a single string. The separator string sep is placed between elements in the resulting string.
`safeHtml`	string	string	Marks string as HTML not requiring auto-escaping.
`stringSlice`	…string	string	Returns the passed strings as a slice of strings. auto-escaping.
`date`	string, Time	string	Format a time in the specified format. For format options, refer to Go’s time format documentation.
`tz`	string, Time	Time	Returns the time in the specified timezone, such as `Europe/Paris`. For available timezone options, refer to the list of tz database time zones.

Here’s an example using some functions to format text:

{{ define "custom_template" }}
  {{ title "hello, world!" }}
  {{ toUpper "Hello, world!" }}
  {{ toLower "Hello, world!" }}
  {{ trimSpace "Hello, world!" }}
  {{ match "a.*" "abc" }}
  {{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
  {{ join "-" (stringSlice "a" "b" "c") }}
  {{ safeHtml "<b>Text</b>"}}
  {{ stringSlice "a" "b" "c" }}
{{ end }}

date and tz can format times. For example, to print the time an alert fired in the format 15:04:05 MST:

{{ define "custom_template" }}
  {{ range .Alerts }}
    {{ .StartsAt | date "15:04:05 MST" }}
  {{ end}}
{{ end }}

You can then use tz to change the timezone from UTC to local time, such as Europe/Paris.

{{ define "custom_template" }}
  {{ range .Alerts }}
    {{ .StartsAt | tz "Europe/Paris" }}
    {{ .StartsAt | tz "Europe/Paris" | date "15:04:05 MST" }}
  {{ end}}
{{ end }}

2024-10-30 21:01:45.227 +0100 CET
21:01:45 CET

Namespaced Functions

Note
Namespaced Functions are not yet generally available in Grafana Cloud.

In addition to the top-level functions, the following namespaced functions are also available:

Collection Functions

Name	Arguments	Returns	Description
`coll.Dict`	key string, value any, …	map	Creates a map with string keys from key/value pairs. All keys are converted to strings. If an odd number of arguments is provided, the last key will have an empty string value.
`coll.Slice`	…any	[]any	Creates a slice (array/list) from the provided arguments. Useful for creating lists that can be iterated over with `range`.
`coll.Append`	value any, list []any	[]any	Creates a new list by appending a value to the end of an existing list. Does not modify the original list.

Example using collection functions:

{{ define "collection.example" }}
{{- /* Create a dictionary of alert metadata */ -}}
{{- $metadata := coll.Dict
    "severity" "critical"
    "team" "infrastructure"
    "environment" "production"
-}}

{{- /* Create a slice of affected services */ -}}
{{- $services := coll.Slice "database" "cache" "api" -}}

{{- /* Append a new service to the list */ -}}
{{- $services = coll.Append "web" $services -}}

{{- /* Use the collections in a template */ -}}
Affected Services: {{ range $services }}{{ . }},{{ end }}

Alert Metadata:
{{- range $k, $v := $metadata }}
  {{ $k }}: {{ $v }}
{{- end }}
{{ end }}

Output:

Affected Services: database,cache,api,web,

Alert Metadata:
  environment: production
  severity: critical
  team: infrastructure

Data Functions

Name	Arguments	Returns	Description
`data.JSON`	jsonString string	any	Parses a JSON string into an object that can be manipulated in the template. Works with both JSON objects and arrays.
`data.ToJSON`	obj any	string	Serializes any object (maps, arrays, etc.) into a JSON string. Useful for creating webhook payloads.
`data.ToJSONPretty`	indent string, obj any	string	Creates an indented JSON string representation of an object. The first argument specifies the indentation string (e.g., spaces).

Example using data functions:

{{ define "data.example" }}
{{- /* First, let's create some alert data as a JSON string */ -}}
{{ $jsonString := `{
  "service": {
    "name": "payment-api",
    "environment": "production",
    "thresholds": {
      "error_rate": 5,
      "latency_ms": 100
    }
  }
}` }}

{{- /* Parse the JSON string into an object we can work with */ -}}
{{ $config := $jsonString | data.JSON }}

{{- /* Create a new alert payload */ -}}
{{ $payload := coll.Dict
    "service" $config.service.name
    "environment" $config.service.environment
    "status" .Status
    "errorThreshold" $config.service.thresholds.error_rate
}}

{{- /* Output the payload in different JSON formats */ -}}
Compact JSON: {{ $payload | data.ToJSON }}

Pretty JSON with 2-space indent:
{{ $payload | data.ToJSONPretty "  " }}
{{ end }}

Output:

Compact JSON: {"environment":"production","errorThreshold":5,"service":"payment-api","status":"resolved"}

Pretty JSON with 2-space indent:
{
  "environment": "production",
  "errorThreshold": 5,
  "service": "payment-api",
  "status": "resolved"
}

Template Functions

Name	Arguments	Returns	Description
`tmpl.Exec`	name string, [context any]	string	Executes a named template and returns the result as a string. Similar to the `template` action but allows for post-processing of the result.
`tmpl.Inline`	template string, context any	string	Renders a string as a template.

{{ define "template.example" -}}
{{ coll.Dict
    "info" (tmpl.Exec `info` . | data.JSON)
    "severity" (tmpl.Inline `{{ print "critical" | toUpper }}` . )
    | data.ToJSONPretty " "}}
{{- end }}

{{- /* Define a sub-template */ -}}
{{ define "info" -}}
{{coll.Dict
    "team" "infrastructure"
    "environment" "production" | data.ToJSON }}
{{- end }}

Output:

{
  "info": {
    "environment": "production",
    "team": "infrastructure"
  },
  "severity": "CRITICAL"
}

Time Functions

Name	Arguments	Returns	Description
`time.Now`		Time	Returns the current local time as a time.Time object. Can be formatted using Go’s time formatting functions.

Example using time functions:

{{ define "time.example" }}
{{- /* Get current time in different formats */ -}}
Current Time (UTC): {{ (time.Now).UTC.Format "2006-01-02 15:04:05 MST" }}
Current Time (Local): {{ (time.Now).Format "Monday, January 2, 2006 at 15:04:05" }}

{{- /* Compare alert time with current time */ -}}
{{ $timeAgo := (time.Now).Sub .StartsAt }}
Alert fired: {{ $timeAgo }} ago
{{ end }}

Output:

Current Time (UTC): 2025-03-08 18:14:27 UTC
Current Time (Local): Saturday, March 8, 2025 at 14:14:27
Alert fired: 25h49m32.78574723s ago

Differences with annotation and label templates

In the alert rule, you can also template annotations and labels to include additional information. For example, you might add a summary annotation that displays the query value triggering the alert.

Annotation and label templates add relevant information to individual alert instances, while notification templates inform about a group of alert instances.

Since both types of templates operate in distinct contexts, the functions and variables available in annotation and label templates differ from those used in notification templates.

Notification template examples

Fri, 03 Apr 2026 19:43:06 +0000

Notification template examples

Notification templates allows you to change the default notification messages.

You can modify the content and format of notification messages. For example, you can customize the content to show only specific information or adjust the format to suit a particular contact point, such as Slack or Email.

Note
Avoid adding extra information about alert instances in notification templates, as this information is only visible in the notification message.

Instead, you should use annotations or labels to add information directly to the alert, ensuring it’s also visible in the alert state and alert history within Grafana. You can then print the new alert annotation or label in notification templates.

This page provides various examples illustrating how to template common notification messages. For more details about notification templates, refer to:

Basic examples

Notification templates can access the notification data using the dot (.). The following examples demonstrate some basic uses of the template language.

Text formatting examples

Text formatting in notification templates varies by contact point type. Each platform has its own formatting syntax:

Slack formatting

For Slack contact points, you can use:

{{ define "slack_formatted_message" -}}
*This text will be bold in Slack*
_This text will be italic in Slack_
Regular text without formatting
{{ end }}

Execute the template:

{{ template "slack_formatted_message" . }}

*This text will be bold in Slack*
_This text will be italic in Slack_
Regular text without formatting

Additional contact point types

Note
Each contact point type has its own formatting requirements:

Some support Markdown-style formatting

Others use HTML tags

Some may not support formatting at all

Check your specific contact point’s documentation for supported formatting syntax.

Template logic examples

Beyond text formatting, you can use template logic to create dynamic notification content. The following examples demonstrate basic template operations:

Conditional logic

To check if there are common labels (.CommonLabels) for all alerts in the notification, use if:

{{ define "custom_message" -}}
{{ if .CommonLabels }}
Alerts have common labels
{{ else }}
There are no common labels
{{ end }}
{{ end }}

Iterating over alerts

To iterate on the alerts in the notification and print a specific label, use range and index:

{{ define "custom_message" -}}
{{ range .Alerts }}
The name of the alert is {{ index .Labels "alertname" }}
{{ end }}
{{ end }}

Alternatively, you can use the . notation to print the value of the key.

{{ define "custom_message" -}}
{{ range .Alerts }}
The name of the alert is {{ .Labels.alertname }}
{{ end }}
{{ end }}

You can then use the template by passing the notification data (dot .):

{{ template "custom_message" . }}

The name of the alert is InstanceDown

The name of the alert is CpuOverload

Print alerts with summary and description

Here’s an example that displays the summary and description annotations for each alert in the notification.

{{ define "custom.alerts" -}}
{{ len .Alerts }} alert(s)
{{ range .Alerts -}}
  {{ template "alert.summary_and_description" . -}}
{{ end -}}
{{ end -}}
{{ define "alert.summary_and_description" }}
  Summary: {{.Annotations.summary}}
  Status: {{ .Status }}
  Description: {{.Annotations.description}}
{{ end -}}

In this example:

A template (alert.summary_and_description) is defined to print the summary, status, and description of one alert.
The main template custom.alerts iterates the list of alerts (.Alerts) in notification data, executing the alert.summary_and_description template to print the details of each alert.

Execute the template by passing the dot (.):

{{ template "custom.alerts" . }}

2 alert(s)

  Summary: The database server db1 has exceeded 75% of available disk space.
  Status: firing
  Description: This alert fires when a database server is at risk of running out of disk space. You should take measures to increase the maximum available disk space as soon as possible to avoid possible corruption.

  Summary: The web server web1 has been responding to 5% of HTTP requests with 5xx errors for the last 5 minutes.
  Status: resolved
  Description: This alert fires when a web server responds with more 5xx errors than is expected. This could be an issue with the web server or a backend service.

Print firing and resolved alerts

The following example is similar to the previous one, but it separates firing and resolved alerts.

{{ define "custom.firing_and_resolved_alerts" -}}
{{ len .Alerts.Resolved }} resolved alert(s)
{{ range .Alerts.Resolved -}}
  {{ template "alert.summary_and_description" . -}}
{{ end }}
{{ len .Alerts.Firing }} firing alert(s)
{{ range .Alerts.Firing -}}
  {{ template "alert.summary_and_description" . -}}
{{ end -}}
{{ end -}}
{{ define "alert.summary_and_description" }}
  Summary: {{.Annotations.summary}}
  Status: {{ .Status }}
  Description: {{.Annotations.description}}
{{ end -}}

Instead of .Alerts, the template accesses .Alerts.Firing and .Alerts.Resolved separately to print details for each alert.

Run the template by passing the dot (.):

{{ template "custom.firing_and_resolved_alerts" . }}

1 resolved alert(s)

  Summary: The database server db1 has exceeded 75% of available disk space.
  Status: resolved
  Description: This alert fires when a database server is at risk of running out of disk space. You should take measures to increase the maximum available disk space as soon as possible to avoid possible corruption.

1 firing alert(s)

  Summary: The web server web1 has been responding to 5% of HTTP requests with 5xx errors for the last 5 minutes.
  Status: firing
  Description: This alert fires when a web server responds with more 5xx errors than is expected. This could be an issue with the web server or a backend service.

Print common labels and annotations

This example displays only the labels and annotations that are common to all alerts in the notification.

{{ define "custom.common_labels_and_annotations" -}}
{{ len .Alerts.Resolved }} resolved alert(s)
{{ len .Alerts.Firing }} firing alert(s)
Common labels: {{ len .CommonLabels.SortedPairs }}
{{ range .CommonLabels.SortedPairs -}}
- {{ .Name }} = {{ .Value }}
{{ end }}
Common annotations: {{ len .CommonAnnotations.SortedPairs }}
{{ range .CommonAnnotations.SortedPairs }}
- {{ .Name }} = {{ .Value }}
{{ end }}
{{ end -}}

Note that .CommonAnnotations and .CommonLabels are part of notification data.

Execute the template by passing the dot (.) as argument:

{{ template "custom.common_labels_and_annotations" . }}

1 resolved alert(s)
1 firing alert(s)
Common labels: 2
- grafana_folder = server_alerts
- team = server_admin

Common annotations: 0

Print individual labels and annotations

This example displays all labels and annotations for each alert in the notification.

{{ define "custom.alert_labels_and_annotations" -}}
{{ len .Alerts.Resolved }} resolved alert(s)
{{ range .Alerts.Resolved -}}
  {{ template "alert.labels_and_annotations" . -}}
{{ end }}
{{ len .Alerts.Firing }} firing alert(s)
{{ range .Alerts.Firing -}}
  {{ template "alert.labels_and_annotations" . -}}
{{ end -}}
{{ end -}}
{{ define "alert.labels_and_annotations" }}
Alert labels: {{ len .Labels.SortedPairs }}
{{ range .Labels.SortedPairs -}}
- {{ .Name }} = {{ .Value }}
{{ end -}}
Alert annotations: {{ len .Annotations.SortedPairs }}
{{ range .Annotations.SortedPairs -}}
- {{ .Name }} = {{ .Value }}
{{ end -}}
{{ end -}}

In this example:

The custom.alert_labels_and_annotations template iterates over the list of resolved and firing alerts, similar to previous examples. It then executes alert.labels_and_annotations for each alert.
The alert.labels_and_annotations template prints all the alert labels and annotations by accessing .Labels.SortedPairs and .Annotations.SortedPairs.

Run the template by passing the dot (.):

{{ template "custom.alert_labels_and_annotations" . }}

1 resolved alert(s)

Alert labels: 4
- alertname = db_server_disk_space
- grafana_folder = server_alerts
- server = db1
- team = server_admin

Alert annotations: 2
- summary = The database server db1 has exceeded 75% of available disk space.
- description = This alert fires when a database server is at risk of running out of disk space. You should take measures to increase the maximum available disk space as soon as possible to avoid possible corruption.

1 firing alert(s)

Alert labels: 4
- alertname = web_server_http_errors
- grafana_folder = server_alerts
- server = web1
- team = server_admin

Alert annotations: 2
- summary = The web server web1 has been responding to 5% of HTTP requests with 5xx errors for the last 5 minutes.
- description = This alert fires when a web server responds with more 5xx errors than is expected. This could be an issue with the web server or a backend service.

Print URLs for runbook and alert data in Grafana

Note that the following example works only for Grafana-managed alerts. It displays some alert data such as DashboardURL, PanelURL, and SilenceURL, which are exclusive to Grafana-managed alerts.

{{ define "custom.alert_additional_details" -}}
{{ len .Alerts.Resolved }} resolved alert(s)
{{ range .Alerts.Resolved -}}
  {{ template "alert.additional_details" . -}}
{{ end }}
{{ len .Alerts.Firing }} firing alert(s)
{{ range .Alerts.Firing -}}
  {{ template "alert.additional_details" . -}}
{{ end -}}
{{ end -}}
{{ define "alert.additional_details" }}
- Dashboard: {{ .DashboardURL }}
- Panel: {{ .PanelURL }}
- AlertGenerator: {{ .GeneratorURL }}
- Silence: {{ .SilenceURL }}
- RunbookURL: {{ .Annotations.runbook_url}}
{{ end -}}

Pass the dot (.) to execute the template:

{{ template "custom.alert_additional_details" . }}

1 resolved alert(s)

- Dashboard: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395
- Panel: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395&viewPanel=31
- AlertGenerator: ?orgId=1
- Silence: https://example.com/alerting/silence/new
- RunbookURL: https://example.com/on-call/db_server_disk_space

1 firing alert(s)

- Dashboard: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395
- Panel: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395&viewPanel=31
- AlertGenerator: ?orgId=1
- Silence: https://example.com/alerting/silence/new
- RunbookURL: https://example.com/on-call/web_server_http_errors

Print a notification title or subject

A title or subject provides a one-line summary of the notification content.

Here’s a basic example that displays the number of firing and resolved alerts in the notification.

{{ define "custom_title" -}}
{{ if gt (.Alerts.Firing | len) 0 }}🚨 {{ .Alerts.Firing | len }} firing alerts. {{ end }}{{ if gt (.Alerts.Resolved | len) 0 }}✅ {{ .Alerts.Resolved | len }} resolved alerts.{{ end }}
{{ end -}}

Execute the template by passing the dot (.) as argument:

{{ template "custom_title" . }}

🚨 1 firing alerts. ✅ 1 resolved alerts.

The next example is a copy of the default title/subject template used in Grafana.

{{ define "copy_of_default_title" -}}
[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ if gt (.Alerts.Resolved | len) 0 }}, RESOLVED:{{ .Alerts.Resolved | len }}{{ end }}{{ end }}] {{ .GroupLabels.SortedPairs.Values | join " " }} {{ if gt (len .CommonLabels) (len .GroupLabels) }}({{ with .CommonLabels.Remove .GroupLabels.Names }}{{ .Values | join " " }}{{ end }}){{ end }}
{{ end }}

This is a more advanced example:

Prints the number of firing and resolved alerts in the notification.
Outputs .GroupLabels, the labels used to group multiple alerts in one notification.
Prints CommonLabels, excluding labels in .GroupLabels.

Execute the template by passing the dot (.):

{{ template "copy_of_default_title" . }}

[FIRING:1, RESOLVED:1] api warning (sql_db)

Print a link to a dashboard with time range

You can include a link to a dashboard or panel in your alert notifications. This is useful when the alert rule is created from a dashboard panel or monitors a target visualized in an existing dashboard.

Including a dashboard link in the notification helps responders quickly navigate to the relevant context for investigation.

Use one of the following methods to include a dashboard link with the correct time range in the alert notification:

You can link the alert rule to a panel. This includes the dashboard and panel URLs via {{.Alert.DashboardURL}} and {{.Alert.PanelURL}}.

{{ define "custom.link_to_dashboard" -}}
{{ range .Alerts -}}
  Dashboard: {{.DashboardURL}}
  Panel: {{ .PanelURL }}
{{ end -}}
{{ end -}}

Run the template using:

{{ template "custom.link_to_dashboard" . }}

Dashboard: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395
Panel: https://example.com/d/uiyahbsdaubsd?from=1740070380000&orgId=1&to=1740074106395&viewPanel=31

These URLs include a time range based on the alert’s timing:

from: One hour before the alert started.
to: The current time if the alert is firing, or the alert’s end time if resolved.

Alternatively, you can use a custom annotation to set the dashboard URL and build the full URL using the from and to query parameters derived from {{.Alert.StartsAt}} and {{.Alert.EndsAt}}.

{{ define "custom.my_dashboard_url_annotation" -}}
{{ range .Alerts -}}

  {{/* StartsAt - 1h */}}
  {{- $from := (.StartsAt.Add -3600000000000).UnixMilli }}

  {{- $to := "" }}
  {{- if eq .Status "resolved" }}
     {{- $to = (.EndsAt).UnixMilli }}
  {{- else -}}
    {{/* Use current time if alert is firing */}}
    {{- $to = (time.Now).UnixMilli }}
  {{- end -}}

  Dashboard: {{.Annotations.MyDashboardURL}}?from={{$from}}&to={{$to}}
{{ end }}
{{ end }}

To use this template, define a custom annotation named MyDashboardURL that contains the base dashboard URL without from and to parameters. For example: http://localhost:3000/d/uiyahbsdaubsd.

Run the template using:

{{ template "custom.my_dashboard_url_annotation" . }}

Dashboard: http://localhost:3000/d/uiyahbsdaubsd?from=1740070380000&to=1740071880000

Custom JSON payload

The custom payload option in the webhook contact point allows you to customize the payload of webhook notifications using a custom template.

The following example generates a custom JSON payload by executing other templates with tmpl.Exec, and using functions like coll.Dict and data.ToJSON to process and format JSON data.

{- /* Generates a pretty-printed JSON payload with alert group info and individual alerts metadata. */ -}}
{{ define "webhook.custom.payload" -}}
  {{ coll.Dict
  "receiver" .Receiver
  "status" .Status
  "alerts" (tmpl.Exec "webhook.custom.simple_alerts" .Alerts | data.JSON)
  "groupLabels" .GroupLabels
  "commonLabels" .CommonLabels
  "commonAnnotations" .CommonAnnotations
  "externalURL" .ExternalURL
  "version" "1"
  "orgId"  (index .Alerts 0).OrgID
  "truncatedAlerts"  .TruncatedAlerts
  "groupKey" .GroupKey
  "state"  (tmpl.Inline "{{ if eq .Status \"resolved\" }}ok{{ else }}alerting{{ end }}" . )
  "allVariables"  .Vars
  "title" (tmpl.Exec "default.title" . )
  "message" (tmpl.Exec "default.message" . )
  | data.ToJSONPretty " "}}
{{- end }}

{{- /* Embed json templates in other json templates. */ -}}
{{ define "webhook.custom.simple_alerts" -}}
  {{- $alerts := coll.Slice -}}
  {{- range . -}}
    {{ $alerts = coll.Append (coll.Dict
    "status" .Status
    "labels" .Labels
    "startsAt" .StartsAt
    "endsAt" .EndsAt
    ) $alerts}}
  {{- end -}}
  {{- $alerts | data.ToJSON -}}
{{- end }}

{
 "alerts": [
  {
   "endsAt": "0001-01-01T00:00:00Z",
   "labels": {
    "alertname": "InstanceDown",
    "grafana_folder": "Test Folder",
    "instance": "instance1"
   },
   "startsAt": "2025-04-21T10:19:46.179Z",
   "status": "firing"
  },
  {
   "endsAt": "2025-04-22T10:19:46.179Z",
   "labels": {
    "alertname": "CpuUsage",
    "grafana_folder": "Test Folder",
    "instance": "instance1"
   },
   "startsAt": "2025-04-22T06:19:46.179Z",
   "status": "resolved"
  }
 ],
 "allVariables": {},
 "commonAnnotations": {},
 "commonLabels": {
  "grafana_folder": "Test Folder",
  "instance": "instance1"
 },
 "externalURL": "http://localhost:3000/",
 "groupKey": "",
 "groupLabels": {
  "group_label": "group_label_value"
 },
 "message": "**Firing**\n\nValue: B=22, C=1\nLabels:\n - alertname = InstanceDown\n - grafana_folder = Test Folder\n - instance = instance1\nAnnotations:\n - summary = Instance instance1 has been down for more than 5 minutes\nSource: https://grafana.com/alerting/grafana/cdeqmlhvflz40f/view?orgId=1\nSilence: http://localhost:3000/alerting/silence/new?alertmanager=grafana\u0026matcher=alertname%3DInstanceDown\u0026matcher=grafana_folder%3DTest+Folder\u0026matcher=instance%3Dinstance1\u0026orgId=1\nDashboard: http://localhost:3000/d/dashboard_uid?from=1745227186179\u0026orgId=1\u0026to=1745317189058\nPanel: http://localhost:3000/d/dashboard_uid?from=1745227186179\u0026orgId=1\u0026to=1745317189058\u0026viewPanel=1\n\n\n**Resolved**\n\nValue: B=22, C=1\nLabels:\n - alertname = CpuUsage\n - grafana_folder = Test Folder\n - instance = instance1\nAnnotations:\n - summary = CPU usage above 90%\nSource: https://grafana.com/alerting/grafana/oZSMdGj7z/view?orgId=1\nSilence: http://localhost:3000/alerting/silence/new?alertmanager=grafana\u0026matcher=alertname%3DCpuUsage\u0026matcher=grafana_folder%3DTest+Folder\u0026matcher=instance%3Dinstance1\u0026orgId=1\nDashboard: http://localhost:3000/d/dashboard_uid?from=1745299186179\u0026orgId=1\u0026to=1745317186179\nPanel: http://localhost:3000/d/dashboard_uid?from=1745299186179\u0026orgId=1\u0026to=1745317186179\u0026viewPanel=1\n",
 "orgId": 1,
 "receiver": "TestReceiver",
 "state": "alerting",
 "status": "firing",
 "title": "[FIRING:1, RESOLVED:1] group_label_value (Test Folder instance1)",
 "truncatedAlerts": null,
 "version": "1"
}

Alerting template language

Fri, 03 Apr 2026 19:43:06 +0000

Alerting template language

Notification templates and alert rule templates, such as annotations and labels, both use the Go template language, text/template.

Both types of templates can use the same keywords, functions, and comparison operators of the Go template language, such as range, if, and, index, eq, and more.

However, it’s important to note that because notifications and alert rules operate in distinct context, some additional variables and functions are only available for either notification or alert rule templates. Refer to:

This documentation provides an overview of the functions and operators of the Go template language that are available for both notification and alert rule templates.

Print

To print the value of something, use {{ and }}. You can print the value of a variable, a field of a variable, the result of a function, or the value of dot.

{{ $values }}
{{ $values.A.Value }}
{{ humanize 1000.0 }}
{{ .Alerts }}

Dot

In text/template, there is a special cursor called dot, written as .. You can think of this cursor as a variable whose value changes depending on where in the template it is used.

At the start of notification templates, dot (.) refers to Notification Data.

{{ .Alerts }}

In annotation and label templates, dot (.) is initialized with all alert data. It’s recommended to use the $labels and $values variables instead to directly access the alert labels and query values.

Note
Dot (.) might refer to something else when used in a range, a with, or when writing templates used in other templates.

If

You can use if statements in templates. For example, you can print Variable empty when a variable is empty:

{{ if $element }}
Element value: {{$element}}
{{ else }}
Element is empty
{{ end }}

With

with is similar to if statements, but unlike if, it updates dot(.) to refer to the value of the expression in with:

{{ with $array }}
There are {{ len . }} item(s)
{{ else }}
There are no alerts
{{ end }}

Range

range iterates over an array or map, and dot (.) is set to the current element of the array:

{{ range $array }}
{{ .itemPropertyName }}
{{ end }}

Optionally, you can handle empty objects using else:

{{ range $array }}
  {{ .itemPropertyName }}
{{ else }}
  Empty array
{{ end }}

You can also get the index of each item within a range by defining index and value variables at the start of the range:

{{ $num_items := len $array }}
{{ range $index, $item := $array }}
This is item {{ $index }} out of {{ $num_items }}
{{ end }}

Additionally, you can use {{break}} to stop the remaining iterations or {{continue}} to stop the current iteration and continue with the next one.

Functions

The global functions available in text/template are:

Function	Description
`and`	Returns the boolean AND of its arguments by returning the first empty argument or the last argument.
`call`	Returns the result of calling the first argument, which must be a function, with the remaining arguments as parameters.
`html`	Returns the escaped HTML equivalent of the textual representation of its arguments.
`index`	Returns the result of indexing its first argument by the following arguments, e.g., `{{ index $labels "instance" }}` returns the `instance` key in the `$labels` map variable.
`slice`	Returns the result of slicing its first argument by the remaining arguments.
`js`	Returns the escaped JavaScript equivalent of the textual representation of its arguments.
`len`	Returns the integer length of its argument, e.g., `{{ len $array }}`
`not`	Returns the boolean negation of its single argument.
`or`	Returns the boolean OR of its arguments by returning the first non-empty argument or the last argument.
`print`	An alias for fmt.Sprint
`printf`	An alias for fmt.Sprintf
`println`	An alias for fmt.Sprintln
`urlquery`	Returns the escaped value of the textual representation of its arguments in a form suitable for embedding in a URL query

For more details, refer to the official documentation on functions in text/template.

Comparison operators

Boolean comparison operators are also available in text/template:

Function	Description
`eq`	Returns the boolean truth of arg1 == arg2
`ne`	Returns the boolean truth of arg1 != arg2
`lt`	Returns the boolean truth of arg1 < arg2
`le`	Returns the boolean truth of arg1 <= arg2
`gt`	Returns the boolean truth of arg1 > arg2
`ge`	Returns the boolean truth of arg1 >= arg2

Variables

Variables in text/template must be created within the template. For example, you can create a variable with the current value of dot (.) and assign a string or another object to the variable like this:

{{ $variable := . }}
{{ $variable := "This is a test" }}
{{ $variable }}

This template outputs:

This is a test

Templates

You can create reusable templates that can be executed from other templates or within the same template.

Define templates using define and the name of the template in double quotes:

{{ define "print_labels" }}
{{ end }}

You should not define templates with the same name as other templates, including default templates such as __subject, __text_values_list, __text_alert_list, default.title and default.message. Where a template has been created with the same name as a default template, or a template in another notification template, Grafana might use either template. Grafana does not prevent, or show an error message, when there are two or more templates with the same name.

Execute templates

You can execute defined templates using template, the name of the template in double quotes, and the cursor that should be passed to the template:

{{ template "print_labels" . }}

Within a template dot refers to the value that is passed to the template.

For example, if a template is passed a list of firing alerts then dot refers to that list of firing alerts:

{{ template "print_alerts" .Alerts }}

If the template is passed the sorted labels for an alert then dot refers to the list of sorted labels:

{{ template "print_labels" .SortedLabels }}

This is useful when writing reusable templates. For example, to print all alerts you might write the following:

{{ template "print_alerts" .Alerts }}

Then to print just the firing alerts you could write this:

{{ template "print_alerts" .Alerts.Firing }}

This works because both .Alerts and .Alerts.Firing is a list of alerts.

{{ define "print_alerts" }}
{{ range . }}
{{ template "print_labels" .SortedLabels }}
{{ end }}
{{ end }}

Note
You cannot create independent, reusable templates for labels and annotations as you can with notification templates. In alert rule templates, you need to write each template inline within the label or annotation field.

Comments

You can add comments with {{/* and */}}:

{{/* This is a comment */}}

To avoid adding line breaks, use:

{{- /* This is a comment with no leading or trailing line breaks */ -}}

Indentation

You can use indentation, both tabs and spaces, and line breaks, to make templates more readable:

{{ range .Alerts }}
  {{ range .Labels.SortedPairs }}
    {{ .Name }} = {{ .Value }}
  {{ end }}
{{ end }}

However, indentation in the template is also present in the text.

Remove spaces and line breaks

In text/template use {{- and -}} to remove leading and trailing spaces and line breaks.

For example, when using indentation and line breaks to make a template more readable:

{{ range .Alerts }}
  {{ range .Labels.SortedPairs }}
    {{ .Name }} = {{ .Value }}
  {{ end }}
{{ end }}

The indentation and line breaks are also present in the text:

    alertname = "Test"

    grafana_folder = "Test alerts"

You can remove the indentation and line breaks from the text changing }} to -}} at the start of each range:

{{ range .Alerts -}}
  {{ range .Labels.SortedPairs -}}
    {{ .Name }} = {{ .Value }}
  {{ end }}
{{ end }}

The indentation and line breaks in the template are now absent from the text:

alertname = "Test"
grafana_folder = "Test alerts"

Use images in notifications

Fri, 03 Apr 2026 19:43:06 +0000

Use images in notifications

Note
Grafana Cloud users can request this feature by opening a support ticket in the Cloud Portal.

Images in notifications helps recipients of alert notifications better understand why an alert has fired or resolved by including a screenshot of the panel associated with the alert.

Note
This feature is not supported in Mimir or Loki, or when Grafana is configured to send alerts to other Alertmanagers such as the Prometheus Alertmanager.

When an alert is fired or resolved Grafana takes a screenshot of the panel associated with the alert. This is determined via the Dashboard UID and Panel ID annotations of the rule. Grafana cannot take a screenshot for alerts that are not associated with a panel.

Grafana takes at most two screenshots for each alert: once when the alert fires and again when the alert is resolved. Screenshots are not re-taken over the lifetime of the alert, instead you should open the panel in Grafana to follow the data in real time. In addition, depending on how alerts are grouped in your notification policies, Grafana might send a notification with many screenshots of the same panel. This happens because Grafana does not know how your alerts are grouped at the time a screenshot is taken, and so acts conservatively by taking a screenshot for every alert.

After a screenshot has been taken Grafana can either upload it to a cloud storage service such as Amazon S3, Azure Blob Storage or Google Cloud Storage; upload the screenshot to it’s internal web server; or upload it to the service that is receiving the notification, such as Slack. Which option you should choose depends on how your Grafana is managed and which integrations you use. More information on this can be found in Requirements.

Refer to the table at the end of this page for a list of contact points and their support for images in notifications.

Requirements

To use images in notifications, Grafana must be set up to use image rendering. You can either install the image rendering plugin or run it as a remote rendering service.
When a screenshot is taken, it is saved to the [data][paths] folder, even if Grafana is configured to upload screenshots to a cloud storage service. Grafana must have write-access to this folder otherwise screenshots cannot be saved to disk and an error is logged for each failed screenshot attempt.
You should use a cloud storage service unless sending alerts to Discord, email, Pushover, Slack or Telegram. These integrations support either embedding screenshots in the email or attaching screenshots to the notification, while other integrations must link screenshots uploaded to a cloud storage bucket. If a cloud storage service has been configured then integrations that support both link screenshots from the cloud storage bucket instead of embedding or attaching screenshots to the notification.
If uploading screenshots to a cloud storage service such as Amazon S3, Azure Blob Storage or Google Cloud Storage; and accessing screenshots in the bucket requires authentication, logging into a VPN or corporate network; then image previews might not work in all instant messaging and communication platforms as some services rewrite URLs to use their CDN. If this happens, we recommend using integrations which support uploading images or disabling images in notifications altogether.
When uploading screenshots to a cloud storage service Grafana uses a random 20 character (30 characters for Azure Blob Storage) filename for each image. This makes URLs hard to guess but not impossible.
Grafana does not delete screenshots from cloud storage. We recommend configuring a retention policy with your cloud storage service to delete screenshots older than 1 month.
If Grafana is configured to upload screenshots to its internal web server, and accessing Grafana requires logging into a VPN or corporate network; image previews might not work in all instant messaging and communication platforms as some services rewrite URLs to use their CDN. If this happens, we recommend using integrations which support uploading images or disabling images in notifications altogether.
Grafana does not delete screenshots uploaded to its internal web server. To delete screenshots from static_root_path/images/attachments after a certain amount of time, we recommend setting up a CRON job.
Note you cannot adjust the number and size of images or their placement in notifications.

Configuration

Note
Grafana Cloud users can request this feature by opening a support ticket in the Cloud Portal.

Having installed either the image rendering plugin, or set up Grafana to use a remote rendering service, set capture in [unified_alerting.screenshots] to true:

# Enable screenshots in notifications. You must have either installed the Grafana image rendering
# plugin, or set up Grafana to use a remote rendering service.
# For more information on configuration options, refer to [rendering].
capture = false

If screenshots should be uploaded to cloud storage then upload_external_image_storage should also be set to true:

# Uploads screenshots to the local Grafana server or remote storage such as Azure, S3 and GCS. Please
# see [external_image_storage] for further configuration options. If this option is false, screenshots
# are persisted to disk for up to temp_data_lifetime.
upload_external_image_storage = false

Restart Grafana for the changes to take effect.

Advanced configuration

We recommend that max_concurrent_screenshots is less than or equal to concurrent_render_request_limit. The default value for both max_concurrent_screenshots and concurrent_render_request_limit is 5:

# The maximum number of screenshots that can be taken at the same time. This option is different from
# concurrent_render_request_limit as max_concurrent_screenshots sets the number of concurrent screenshots
# that can be taken at the same time for all firing alerts where as concurrent_render_request_limit sets
# the total number of concurrent screenshots across all Grafana services.
max_concurrent_screenshots = 5

Supported contact points

Grafana supports a wide range of contact points with varied support for images in notifications. The table below shows the list of all contact points supported in Grafana and their support for uploading screenshots to the receiving service and referencing screenshots that have been uploaded to a cloud storage service.

Name	Upload from disk	Reference from cloud storage
DingDing	No	No
Discord	Yes (Maximum of 10 per notification)	Yes (Maximum of 10 per notification)
Email	Yes (Embedded in the email)	Yes
Google Chat	No	Yes
Kafka	No	No
Line	No	No
MQTT	No	No
Microsoft Teams	No	Yes
Opsgenie	No	Yes
PagerDuty	No	Yes
Prometheus Alertmanager	No	No
Pushover	Yes (Maximum of 1 per notification)	No
Sensu Go	No	No
Slack	Yes (when using Bot tokens, maximum of 5 per notification)	Yes (when using webhooks, maximum of 1 per notification)
Telegram	Yes	No
Threema	No	No
VictorOps	No	No
Webhook	No	Yes

Limitations

This feature is not supported in Mimir or Loki, or when Grafana is configured to send alerts to other Alertmanagers such as the Prometheus Alertmanager.
This feature is not supported when using custom templates in email notifications.
A number of contact points support at most one image per notification. In this case, just the first image is either uploaded to the receiving service or referenced from cloud storage per notification.
When multiple alerts are sent in a single notification a screenshot might be included for each alert. The order the images are shown is random.
If uploading screenshots to a cloud storage service such as Amazon S3, Azure Blob Storage or Google Cloud Storage; and accessing screenshots in the bucket requires authentication, logging into a VPN or corporate network; image previews might not work in all instant messaging and communication platforms as some services rewrite URLs to use their CDN.

Troubleshooting

If Grafana has been set up to send images in notifications, however notifications are still being received without them, follow the troubleshooting steps below:

Check that images in notifications has been set up as per the instructions.
Enable debug logging in Grafana and look for logs with the logger ngalert.image.
If the alert is not associated with a dashboard there are logs for Cannot take screenshot for alert rule as it is not associated with a dashboard.
If the alert is associated with a dashboard, but no panel in the dashboard, there are logs for Cannot take screenshot for alert rule as it is not associated with a panel.
If images cannot be taken because of mis-configuration or an issue with image rendering there are logs for Failed to take an image including the Dashboard UID, Panel ID, and the error message.
Check that the contact point supports images in notifications and whether it supports uploading images to the receiving service or referencing images that have been uploaded to a cloud storage service.

Monitor

Grafana provides the following metrics to observe the performance and failure rate of images in notifications. For example, if a screenshot could not be taken within the expected time (10 seconds) then the counter grafana_screenshot_failures_total is updated.

grafana_alerting_image_cache_hits_total
grafana_alerting_image_cache_misses_total
grafana_screenshot_duration_seconds
grafana_screenshot_failures_total
grafana_screenshot_successes_total
grafana_screenshot_upload_failures_total
grafana_screenshot_upload_successes_total