Variables on Grafana Labs

Add variables

Tue, 23 Jun 2026 13:06:40 +0000

Add variables

In addition to the built-in global variables that come with Grafana, you can create your own variables. The following table lists the types of variables you can create:

Variable type	Description
Query	Query-generated list of values such as metric names, server names, sensor IDs, data centers, and so on. Add a query variable.
Custom	Define the variable options manually using a comma-separated list. Add a custom variable.
Text box	Display a free text input field with an optional default value. Add a text box variable.
Constant	Define a hidden constant. Add a constant variable.
Data source	Quickly change the data source for an entire dashboard. Add a data source variable.
Interval	Interval variables represent time spans. Add an interval variable.
Switch	Display a switch that allows you to toggle between two configurable values for enabled and disabled states. Add a switch variable.

Note
In Grafana 13.1, Ad hoc filters have been renamed Filter and Group by and extended by adding grouping for Prometheus and Loki data sources. However, in the dashboard schema, they’re still referred to as "kind": "AdhocVariable".

For information on the Filter and Group by feature, refer to the documentation.

Enter general options for any variable

To create a variable, follow these steps:

Click Edit in the top-right corner of the dashboard.
In the toolbar, click the Dashboard options icon to open the sidebar.
In the sidebar, click Settings.
Go to the Variables tab.
Click Add variable, or if there are already variables, + New variable.
Choose an option in the Select variable type drop-down list.
Enter a Name for the variable.
(Optional) In the Label field, enter the display name for the variable drop-down list.

If you don’t enter a display name, then the drop-down list label is the variable name.
(Optional) In the Description field, enter a description of the variable. The description appears as an info icon tooltip next to the variable name on the dashboard.

Descriptions support links. You can use Markdown-style links ([link text](https://example.com)) or paste bare URLs (https://example.com). Only http and https URLs are rendered as clickable links—other protocols are displayed as plain text.
Choose a Display option:
- Above dashboard - The variable drop-down list displays above the dashboard with the variable Name or Label value. This is the default.
- Above dashboard, label hidden - The variable drop-down list displays above the dashboard, but without showing the name of the variable.
- Controls menu - The variable is displayed in the dashboard controls menu instead of above the dashboard. The dashboard controls menu appears as a button in the dashboard toolbar.
- Hidden - No variable drop-down list is displayed on the dashboard.
Click one of the following links to complete the steps for adding your selected variable type:
- Query
- Custom
- Textbox
- Constant
- Data source
- Interval
- Switch

Tip
To add variables without leaving the dashboard, click the Add new element icon in the dashboard toolbar, and select Variable. For more information, refer to the Dashboard controls documentation.

Variable best practices

Variable drop-down lists are displayed in the order in which they’re listed in the Variables tab in dashboard settings, so put the variables that you change often at the top, so they’re shown first.
By default, variables don’t have a default value. This means that the topmost value in the drop-down list is always preselected. If you want to pre-populate a variable with an empty value, you can use the following workaround in the variable settings:
1. Select the Include All Option checkbox.
2. In the Custom all value field, enter a value like .+.

Add a query variable

Query variables enable you to write a data source query that can return a list of metric names, tag values, or keys. For example, a query variable might return a list of server names, sensor IDs, or data centers. The variable values change as they dynamically fetch options with a data source query.

Query variables are generally only supported for strings. If your query returns numbers or any other data type, you might need to convert them to strings to use them as variables. For the Azure data source, for example, you can use the tostring function for this purpose.

Query expressions can contain references to other variables and in effect create linked variables. Grafana detects this and automatically refreshes a variable when one of its linked variables change.

Note
Query expressions are different for each data source. For more information, refer to the documentation for your data source.

Enter general options.

Configure the following options:

Option	Description
Data source	Select a target data source in the Data source drop-down list. You can also click Open advanced data source picker to see more options, including adding a data source (Admins only). For more information about data sources, refer to Add a data source.
Query type	Select an option in the drop-down list and fill in the query fields accordingly. For more information, refer to the Query type section following these steps.
Regex	(Optional) Type a regular expression in the field to filter or capture specific parts of the names returned by your data source query. To see examples, refer to Filter variables with a regular expression.
Apply regex to	Select Variable value or Display text to choose where the regular expression pattern is applied. The default is Variable value.
Sort	Select the sort order for values to be displayed in the drop-down list. The default option, Disabled, means that the order of options returned by your data source query is used.
Refresh	Select when the variable should update options: On dashboard load - Queries the data source every time the dashboard loads. This slows down dashboard loading, because the variable query needs to be completed before dashboard can be initialized. On time range change - Queries the data source every time the dashboard loads and when the dashboard time range changes. Use this option if your variable options query contains a time range filter or is dependent on the dashboard time range.
Use static options	(Optional) Toggle on the switch to add custom options in addition to the query results: Make entries in the Value and Display text fields. Click + Add new option to add another static option. Repeat these steps as many times as needed.
Multi-value	Enables multiple values to be selected at the same time. For more information, refer to Selection Options.
Allow custom values	Enables users to add custom values to the list. Only applies to CSV custom values. For more information, refer to Selection Options.
Include All option	Enables an option to include all variables. For more information, refer to Selection Options.

Click Run query to test the variable.
In the Preview of values section, Grafana displays a list of the current variable values. Review them to ensure they match what you expect.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Query type

The query field varies according to your data source. Some data sources have custom query editors.

Each data source defines how the variable values are extracted. The typical implementation uses every string value returned from the data source response as a variable value. Make sure to double-check the documentation for the data source.

Some data sources let you provide custom “display names” for the values. For instance, the PostgreSQL, MySQL, and Microsoft SQL Server plugins handle this by looking for fields named __text and __value in the result. Other data sources may look for text and value or use a different approach. Always remember to double-check the documentation for the data source.

If you need more room in a single input field query editor, then hover your cursor over the lines in the lower right corner of the field and drag downward to expand.

Add a custom variable

Use a custom variable for a value that doesn’t change, such as a number or a string.

For example, if you have server names or region names that never change, then you might want to create them as custom variables rather than query variables. Because they don’t change, you might use them in chained variables rather than other query variables. That would reduce the number of queries Grafana must send when chained variables are updated.

Enter general options.

Configure the following options:

Option	Description
CSV	Enter a flat list of values for the variable in a comma-separated list. You can include numbers, strings, or key/value pairs separated by a space and a colon. For example, `key1 : value1,key2 : value2`.
JSON	Provide a JSON array of objects where each object can have any number of properties that can be referenced. For more information refer, to Configure multi-property variables.
Multi-value	Enables multiple values to be selected at the same time. For more information, refer to Selection Options.
Allow custom values	Enables users to add custom values to the list. Only applies to CSV custom values. For more information, refer to Selection Options.
Include All option	Enables an option to include all variables. For more information, refer to Selection Options.

Click Run query to test the variable.
In the Preview of values section, Grafana displays a list of the current variable values. If you’ve entered a JSON array, the preview is a table that includes all the value properties. Review them to ensure they match what you expect.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Add a text box variable

Text box variables display a free text input field with an optional default value. This is the most flexible variable, because you can enter any value. Use this type of variable if you have metrics with high cardinality or if you want to update multiple panels in a dashboard at the same time.

For more information about cardinality, refer to What are cardinality spikes and why do they matter?

Enter general options.
(Optional) Under the Text options section of the page, in the Default value field, enter the default value for the variable.

If you do not enter anything in this field, then Grafana displays an empty text box for users to type text into.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Add a constant variable

Constant variables enable you to define a hidden constant. This is useful for metric path prefixes for dashboards you want to share. When you export a dashboard, constant variables are converted to import options.

Constant variables are not flexible. Each constant variable only holds one value, and it cannot be updated unless you update the variable settings.

Constant variables are useful when you have complex values that you need to include in queries but don’t want to retype in every query. For example, if you had a server path called i-0b6a61efe2ab843gg, then you could replace it with a variable called $path_gg.

Enter general options.
Under the Constant options section of the page, in the Value field, enter the variable value.

You can enter letters, numbers, and symbols. You can even use wildcards if you use raw format.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Add a data source variable

Data source variables enable you to quickly change the data source for an entire dashboard. They’re useful if you have multiple instances of a data source, perhaps in different environments.

Enter general options.

Configure the following options:

Option	Description
Type	Select the target data source for the variable.
Instance name filter	(Optional) Enter a regular expression filter for which data source instances to choose from in the variable value drop-down list. Leave this field empty to display all instances.
Multi-value	Enables multiple values to be selected at the same time. For more information, refer to Selection Options.
Allow custom values	Enables users to add custom values to the list. For more information, refer to Selection Options.
Include All option	Enables an option to include all variables. For more information, refer to Selection Options.

Click Run query to test the variable.
In the Preview of values section, Grafana displays a list of the current variable values. Review them to ensure they match what you expect.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Add an interval variable

Use an interval variable to represents time spans such as 1m,1h, 1d. You can think of them as a dashboard-wide “group by time” command. Interval variables change how the data is grouped in the visualization. You can also use the Auto Option to return a set number of data points per time span.

You can use an interval variable as a parameter to group by time (for InfluxDB), date histogram interval (for Elasticsearch), or as a summarize function parameter (for Graphite).

Enter general options.

Configure the following options:

Option	Description
Values	Enter the time range intervals that you want to appear in the variable drop-down list. The following time units are supported: `s (seconds)`, `m (minutes)`, `h (hours)`, `d (days)`, `w (weeks)`, `M (months)`, and `y (years)`. You can also accept or edit the default values: `1m,10m,30m,1h,6h,12h,1d,7d,14d,30d`.
Auto option	(Optional) Select on the checkbox if you want to add the `auto` option to the list. This option allows you to specify how many times the current time range should be divided to calculate the current `auto` time span.
Step count	Select the number of times the current time range is divided to calculate the value, similar to the Max data points query option. For example, if the current visible time range is 30 minutes, then the `auto` interval groups the data into 30 one-minute increments. The default value is 30 steps. Only displayed when you select the Auto option checkbox.
Min interval	The minimum threshold below which the step count intervals doesn’t divide the time. To continue the 30 minute example, if the minimum interval is set to 2m, then Grafana would group the data into 15 two-minute increments. Only displayed when you select the Auto option checkbox.

Click Run query to test the variable.
In the Preview of values section, Grafana displays a list of the current variable values. Review them to ensure they match what you expect.
Click Save in the top-right corner.
Enter an optional description of your changes and click Save.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Interval variable examples

The following example shows a template variable myinterval in a Graphite function:

summarize($myinterval, sum, false)

The following example shows a more complex Graphite example, from the Graphite Template Nested Requests panel:

groupByNode(summarize(movingAverage(apps.$app.$server.counters.requests.count, 5), '$interval', 'sum', false), 2, 'sum')

Add a switch variable

Switch variables display a switch with two configurable values representing enabled and disabled states. This variable type is useful when you need to:

Toggle between different query conditions
Enable or disable specific filters
Switch between different visualization modes
Control boolean parameters in your data sources

Enter general options.

Configure the following options:

Option	Description
Value pair type	Select one of the following predefined options: True / False - Uses boolean values `true` and `false`. 1 / 0 - Uses numeric values `1` and `0`. Yes / No - Uses string values `yes` and `no`. Custom - Allows you to define custom values for both enabled and disabled states.
Enabled value	If you selected Custom, configure the custom values. Enter the value that represents the enabled state (for example, “on”).
Disabled value	If you selected Custom, enter the value that represents the disabled state (for example, “off”).

Click Save dashboard.
Click Back to list to add or edit other variables, or Back to dashboard and then Exit edit.

Switch variable examples

The following example shows a switch variable $debug_mode used in a Prometheus query to conditionally include debug labels:

up{job="my-service"} and ($debug_mode == "true" or on() vector(0))

The following example shows a switch variable $show_errors used to filter log entries:

{job="application"} |= ($show_errors == "1" ? "ERROR" : "")

You can also use switch variables in panel titles and other dashboard elements:

{{#if debug_mode}}Debug Mode: {{/if}}Application Metrics

Variable selection options

Selection Options are a feature you can use to manage variable option selections for query and custom variables. All selection options are optional, and they’re off by default.

Multi-value variables

Interpolating a variable with multiple values selected is tricky as it’s not straight forward how to format the multiple values into a string that’s valid in the given context where the variable is used. Grafana tries to solve this by allowing each data source plugin to inform the templating interpolation engine what format to use for multiple values.

Note
The Custom all value option on the variable must be blank for Grafana to format all values into a single string. If it’s left blank, then Grafana concatenates (adds together) all the values in the query. Something like value1,value2,value3. If a custom all value is used, then instead the value is something like * or all.

Multi-value variables with a Graphite data source

Graphite uses glob expressions. A variable with multiple values would, in this case, be interpolated as {host1,host2,host3} if the current variable value was host1, host2, and host3.

Multi-value variables with a Prometheus or InfluxDB data source

InfluxDB and Prometheus use regular expressions, so the same variable would be interpolated as (host1|host2|host3). Every value would also be regular expression escaped. If not, a value with a regular expression control character would break the regular expression.

Multi-value variables with an Elastic data source

Elasticsearch uses Lucene query syntax, so the same variable would be formatted as ("host1" OR "host2" OR "host3"). In this case, every value must be escaped so that the value only contains Lucene control words and quotation marks.

Variable indexing

If you have a multi-value variable that’s formatted as an array, you can use array positions to reference the values rather than the actual values. You can use this functionality in dashboard panels to filter data, and when you do so, the array is maintained.

To reference variable values this way, use the following syntax:

${query0.0}

The preceding syntax references the first, or 0, position in the array.

In the following example, there’s an array of three values, 1t, 2t, and 3t, and rather than referencing those values, the panel query references the second value in the array using the syntax ${query0.1}:

Troubleshoot multi-value variables

Automatic escaping and formatting can cause problems and it can be tricky to grasp the logic behind it. Especially for InfluxDB and Prometheus where the use of regular expression syntax requires that the variable is used in regular expression operator context.

If you don’t want Grafana to do this automatic regular expression escaping and formatting, then you must do one of the following:

Turn off the Multi-value or Include All option options.
Use the raw variable format.

Custom all value

This option is only visible if the Include All option is selected.

Enter regular expressions, globs, or Lucene syntax in the Custom all value field to define the value of the All option.

By default the All value includes all options in combined expression. This can become very long and can have performance problems. Sometimes it can be better to specify a custom all value, like a wildcard regular expression.

In order to have custom regular expression, globs, or Lucene syntax in the Custom all value option, it’s never escaped so you have to think about what’s a valid value for your data source.

Include All option

Grafana adds an All option to the variable drop-down list. If a user selects this option, then all variable options are selected.

Global variables

Tue, 23 Jun 2026 13:06:40 +0000

Global variables

Grafana has global built-in variables that can be used in expressions in the query editor. This page lists them in alphabetical order and defines them. Most variables are useful in queries, dashboard links, panel links, and data links — but some, like $__url_time_range, are intended only for use in links, not query editors.

`$__dashboard`

This variable is the name of the current dashboard.

`$from` and `$to`

Grafana has built-in time range variables: $__from and $__to. They’re always interpolated as epoch milliseconds by default, but you can control date formatting.

Syntax	Example result	Description
`${__from}`	1594671549254	Unix millisecond epoch
`${__from:date}`	2020-07-13T20:19:09.254Z	No arguments, defaults to ISO 8601/RFC 3339
`${__from:date:iso}`	2020-07-13T20:19:09.254Z	ISO 8601/RFC 3339
`${__from:date:seconds}`	1594671549	Unix seconds epoch
`${__from:date:YYYY-MM}`	2020-07	Any custom date format that doesn’t include the `:` character. Uses browser time. Use `:date` or `:date:iso` for UTC

The syntax above also works with ${__to}.

You can use this variable in URLs, as well. For example, you can send a user to a dashboard that shows a time range from six hours ago until now: https://play.grafana.org/d/000000012/grafana-play-home?viewPanel=2&orgId=1?from=now-6h&to=now

`$__interval`

You can use the $__interval variable as a parameter to group by time (for InfluxDB, MySQL, Postgres, MSSQL), Date histogram interval (for Elasticsearch), or as a summarize function parameter (for Graphite).

Grafana automatically calculates an interval that can be used to group by time in queries. When there are more data points than can be shown on a graph, then queries can be made more efficient by grouping by a larger interval. It’s more efficient to group by 1 day than by 10s when looking at 3 months of data. The graph looks the same and the query is faster. The $__interval is calculated using the time range and the width of the graph (the number of pixels).

Approximate Calculation: (to - from) / resolution

For example, when the time range is 1 hour and the graph is full screen, then the interval might be calculated to 2m - points are grouped in 2 minute intervals. If the time range is 6 months and the graph is full screen, then the interval might be 1d (1 day) - points are grouped by day.

In the InfluxDB data source, the legacy variable $interval is the same variable. $__interval should be used instead.

The InfluxDB and Elasticsearch data sources have Group by time interval fields that are used to hard code the interval or to set the minimum limit for the $__interval variable (by using the > syntax -> >10m).

`$__interval_ms`

This variable is the $__interval variable in milliseconds, not a time interval formatted string. For example, if the $__interval is 20m then the $__interval_ms is 1200000.

`$__name`

This variable is only available in the Singlestat panel and can be used in the prefix or suffix fields on the Options tab. The variable is replaced with the series name or alias.

Note
The Singlestat panel is no longer available from Grafana 8.0.

`$__org`

This variable is the ID of the current organization. ${__org.name} is the name of the current organization.

`$__user`

${__user.id} is the ID of the current user. ${__user.login} is the login handle of the current user. ${__user.email} is the email for the current user.

`$__range`

Currently only supported for Prometheus and Loki data sources. This variable represents the range for the current dashboard. It’s calculated by to - from. It has a millisecond and a second representation called $__range_ms and $__range_s.

`$__rate_interval`

Currently only supported for Prometheus data sources. The $__rate_interval variable is meant to be used in the rate function. Refer to Prometheus query variables for details.

`$__rate_interval_ms`

This variable is the $__rate_interval variable in milliseconds, not a time-interval-formatted string. For example, if the $__rate_interval is 20m then the $__rate_interval_ms is 1200000.

`$timeFilter` or `$__timeFilter`

The $timeFilter variable returns the currently selected time range as an expression. For example, the time range interval Last 7 days expression is time > now() - 7d.

This is used in several places, including:

The WHERE clause for the InfluxDB data source. Grafana adds it automatically to InfluxDB queries when in Query Editor mode. You can add it manually in Text Editor mode: WHERE $timeFilter.
Log Analytics queries in the Azure Monitor data source.
SQL queries in MySQL, Postgres, and MSSQL.
The $__timeFilter variable is used in the MySQL data source.

`$__timezone`

The $__timezone variable returns the currently selected time zone, either utc or an entry of the IANA time zone database (for example, America/New_York).

If the currently selected time zone is Browser Time, Grafana tries to determine your browser time zone.

`$__url_time_range`

The $__url_time_range variable returns the current dashboard time range as URL query parameters. It’s intended for use in data links and panel links, not in query editors.

The variable expands to a string like from=1607687293000&to=1607687293100, where the values are Unix millisecond timestamps matching the current time range selection.

You must include the ? or & separator yourself when constructing URLs:

Usage	Example result
`https://example.com/d/abc?${__url_time_range}`	`https://example.com/d/abc?from=1594671549254&to=1594672349254`
`https://example.com/d/abc?orgId=1&${__url_time_range}`	`https://example.com/d/abc?orgId=1&from=1594671549254&to=1594672349254`

To link to another dashboard while preserving the current time range, follow this pattern:

https://your-grafana/d/other-dashboard?${__url_time_range}

To also pass a variable value from the current dashboard, follow this pattern:

https://your-grafana/d/other-dashboard?{__url_time_range}&var-host= {host}

Note
$__url_time_range always uses Unix millisecond epoch timestamps. To include only the start or end of the time range with specific formatting, use $__from and $__to variables instead.

Advanced variable configurations

Tue, 23 Jun 2026 13:06:40 +0000

Advanced variable configurations

The advanced variable configurations described on this page help you build dashboards that adapt to complex data structures and user selections:

Multi-property variables: Map one logical value to multiple source-specific values.
Chained variables: Update the options in one variable based on the selections in another.
Regular expression filtering: Filter the values returned by a variable query.

These configurations are useful for dashboards that span multiple environments, data sources, regions, clusters, namespaces, or other hierarchical data.

Multi-property variables

If a multi-source dashboard uses multiple values for the same logical concept, such as an environment identified as dev in one source and development in another, use a multi-property variable to reference those values from one variable. This lets you map related identifiers together and reference the property you need in panels and queries.

To do so, configure a JSON array in which each object can have any number of properties. Then, you can reference any of the properties as you use those variables.

This applies to the following variable types:

Custom
Query
- Infinity
- PostgreSQL

Multi-property custom variables

To create a custom variable with multiple properties, define a JSON array, like this:

[
  { "value": "1", "text": "Development", "aws": "dev", "azure": "development", "google": "googledev" },
  { "value": "2", "text": "Staging", "aws": "stag", "azure": "staging", "google": "googlestag" },
  { "value": "3", "text": "Production", "aws": "prod", "azure": "production", "google": "googleprod" }
]

This is how those values are displayed in a preview:

Then you can use ${varName.someProperty} syntax to reference any property in your dashboard panels or metrics:

You can even deeply nest properties and still access them using familiar variable syntax. In the following example, each user has an address property with all the elements of an address nested within it:

Multi-property query variables

Because query configuration is different for each data source, there’s no one way to set up a JSON array to create a multi-property query variable. For PostgreSQL, refer to PostgreSQL template variables. For other data sources, refer to the relevant Data sources documentation for preinstalled data source plugins. For configuration information on all other data source plugins, refer to the Plugins documentation.

Chained variables

Chained variables, also called linked variables or nested variables, are query variables with one or more other variables in their variable query.

Chained variables create dependent relationships where the options available in one variable depend on the selections made in another. This pattern enables cascading filters that help users drill down through hierarchical data structures.

Cascading filter patterns are common in multi-tier filtering scenarios such as region > cluster > namespace > pod. Each level narrows the available options based on the previous selection, creating an intuitive navigation experience through your infrastructure or data hierarchy.

Technically, there is no limit to how many variables you can chain together, but the more links you have, the greater the query load.

Grafana Play dashboard examples

The following Grafana Play dashboards contain basic chained variables, only two layers deep. To view the variables and their settings, click Edit and then Settings; then go to the Variables tab. Both examples are expanded in the following section.

While the examples are data source-specific, the concepts can be applied broadly.

Graphite example explained

In this example, there are several applications. Each application has a different subset of servers. It’s based on the Graphite Templated Nested.

Now, you could make separate variables for each metric source, but then you have to know which server goes with which app. A better solution is to use one variable to filter another. In this example, when the user changes the value of the app variable, it changes the drop-down options returned by the server variable. Both variables use the Multi-value option and Include all option, enabling users to select some or all options presented at any time.

`app` variable

The query for this variable returns all the applications that exist.

apps.*

The values returned are backend, country, fakesite, and All.

`server` variable

The query for this variable returns all servers for the currently selected application.

apps.$app.*

If the user selects backend, then the query changes to:

apps.backend.*

The query returns all servers associated with backend, including backend_01, backend_02, and so on.

If the user selects fakesite, then the query changes to:

apps.fakesite.*

The query returns all servers associated with fakesite, including web_server_01, web_server_02, and so on.

More variables

Note
This example is theoretical. The Graphite server used in the example doesn’t contain CPU metrics.

The dashboard stops at two levels, but you could keep going. For example, if you wanted to get CPU metrics for selected servers, you could copy the server variable and extend the query so that it reads:

apps.$app.$server.cpu.*

This query returns all the CPU metrics for the selected server.

Depending on what variable options the user selects, you could get queries like:

apps.backend.backend_01.cpu.*
apps.{backend.backend_02,backend_03}.cpu.*
apps.fakesite.web_server_01.cpu.*

InfluxDB example explained

In this example, you have several data centers. Each data center has a different subset of hosts. It’s based on the InfluxDB Templated dashboard.

In this example, when the user changes the value of the datacenter variable, it changes the drop-down options returned by the host variable. The host variable uses the Multi-value option and Include all option, allowing users to select some or all options presented at any time. The datacenter does not use either option, so you can only select one data center at a time.

`datacenter` variable

The query for this variable returns all the data centers that exist.

SHOW TAG VALUES WITH KEY = "datacenter"

The values returned are America, Africa, Asia, and Europe.

`host` variable

The query for this variable returns all hosts for the currently selected data center.

SHOW TAG VALUES WITH KEY = "hostname" WHERE "datacenter" =~ /^$datacenter$/

If the user selects America, then the query changes to:

SHOW TAG VALUES WITH KEY = "hostname" WHERE "datacenter" =~ /^America/

The query returns all servers associated with America, including server1, server2, and so on.

If the user selects Europe, then the query changes to:

SHOW TAG VALUES WITH KEY = "hostname" WHERE "datacenter" =~ /^Europe/

The query returns all servers associated with Europe, including server3, server4, and so on.

More variables

Note
This example is theoretical. The InfluxDB server used in the example doesn’t contain CPU metrics.

The dashboard stops at two levels, but you could keep going. For example, if you wanted to get CPU metrics for selected hosts, you could copy the host variable and extend the query so that it reads:

SHOW TAG VALUES WITH KEY = "cpu" WHERE "datacenter" =~ /^$datacenter$/ AND "host" =~ /^$host$/

This query returns the CPU metrics for the selected host.

Depending on what variable options the user selects, you could get queries like:

SHOW TAG VALUES WITH KEY = "cpu" WHERE "datacenter" =~ /^America/ AND "host" =~ /^server2/
SHOW TAG VALUES WITH KEY = "cpu" WHERE "datacenter" =~ /^Africa/ AND "host" =~ /^server/7/
SHOW TAG VALUES WITH KEY = "cpu" WHERE "datacenter" =~ /^Europe/ AND "host" =~ /^server3+server4/

Best practices for chained variables

The following practices make your dashboards and variables easier to use.

New linked variables creation

Chaining variables create parent/child dependencies. You can envision them as a ladder or a tree.
The easiest way to create a new chained variable is to copy the variable that you want to base the new one on. In the variable list, click the Duplicate variable icon to the right of the variable entry to create a copy. You can then add on to the query for the parent variable.
New variables created this way appear at the bottom of the list. You might need to drag it to a different position in the list to get it into a logical order.

Variable order

You can change the orders of variables in the dashboard variable list by clicking the up and down arrows on the right side of each entry. Grafana lists variable dropdowns left to right according to this list, with the variable at the top on the far left.

List variables that don’t have dependencies at the top, before their child variables.
Each variable should follow the one it’s dependent on.
Remember there is no indication in the UI of which variables have dependency relationships. List the variables in a logical order to make it easier for others to use.

Complexity consideration

The more layers of dependency you have in variables, the longer it takes to update dashboards after you change variables.

For example, if you have a series of four linked variables (country, region, server, metric) and you change a root variable value (country), then Grafana must run queries for all the dependent variables before it updates the visualizations in the dashboard.

Filter variables with regular expressions

Using the Regex query option, you filter the list of options returned by the variable query or modify the options returned.

This section shows how to use a regular expression to filter or modify values in the variable drop-down list.

Using the Regex query option, you filter the list of options returned by the Variable query or modify the options returned. For more information, refer to the Mozilla guide on Regular expressions.

Examples of filtering on the following list of options:

backend_01
backend_02
backend_03
backend_04

Filter to return only the options that end with `01` or `02`

Regex:

/(01|02)$/

Result:

backend_01
backend_02

Filter and modify the options using a regular expression to capture group to return part of the text

Regex:

/.*(01|02)/

Result:

01
02

Filter and modify: Prometheus Example

List of options:

up{instance="demo.robustperception.io:9090",job="prometheus"} 1 1521630638000
up{instance="demo.robustperception.io:9093",job="alertmanager"} 1 1521630638000
up{instance="demo.robustperception.io:9100",job="node"} 1 1521630638000

Regex:

/.*instance="([^"]*).*/

Result:

demo.robustperception.io:9090
demo.robustperception.io:9093
demo.robustperception.io:9100

Filter and modify using named text and value capture groups

Using named capture groups, you can capture separate ’text’ and ‘value’ parts from the options returned by the variable query. This allows the variable drop-down list to contain a friendly name for each value that can be selected.

For example, when querying the node_hwmon_chip_names Prometheus metric, the chip_name is a lot friendlier than the chip value. So the following variable query result:

node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_0",chip_name="enp216s0f0np0"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_1",chip_name="enp216s0f0np1"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_2",chip_name="enp216s0f0np2"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_3",chip_name="enp216s0f0np3"} 1

Passed through the following regular expression:

/chip_name="(?<text>[^"]+)|chip="(?<value>[^"]+)/g

Would produce the following drop-down list:

Display Name          Value
------------          -------------------------
enp216s0f0np0         0000:d7:00_0_0000:d8:00_0
enp216s0f0np1         0000:d7:00_0_0000:d8:00_1
enp216s0f0np2         0000:d7:00_0_0000:d8:00_2
enp216s0f0np3         0000:d7:00_0_0000:d8:00_3

Note
Only text and value capture group names are supported.

Variable syntax

Tue, 23 Jun 2026 13:06:40 +0000

Variable syntax

Panel titles and metric queries can refer to variables using two different syntaxes:

$varname This syntax is easy to read, but it doesn’t allow you to use a variable in the middle of a word. Example: apps.frontend.$server.requests.count
${var_name} Use this syntax when you want to interpolate a variable in the middle of an expression.
${var_name:<format>} This format gives you more control over how Grafana interpolates values. Refer to Advanced variable format options for more detail on all the formatting types.
[[varname]] Do not use. Deprecated syntax, that will be removed in a future release.

Before queries are sent to your data source, the query is interpolated, meaning the variable is replaced with its current value. During interpolation, the variable value might be escaped to conform to the syntax of the query language and where it’s used. For example, variables in InfluxDB or Prometheus regular expression queries are automatically escaped. Read the data source specific documentation topic for details on value escaping during interpolation.

For advanced syntax to override data source default formatting, refer to Advanced variable format options.

Advanced variable format options

The formatting of the variable interpolation depends on the data source, but there are some situations where you might want to change the default formatting.

For example, the default for the MySql data source is to join multiple values as comma-separated with quotes: 'server01','server02'. In some cases, you might want to have a comma-separated string without quotes: server01,server02. You can make that happen with advanced variable formatting options listed below.

General syntax

Syntax: ${var_name:option}

Test the formatting options on the Grafana Play site.

If any invalid formatting option is specified, then glob is the default/fallback option.

An alternative syntax (that might be deprecated in the future) is [[var_name:option]].

CSV

Formats variables with multiple values as a comma-separated string.

servers = ['test1', 'test2']
String to interpolate: '${servers:csv}'
Interpolation result: 'test1,test2'

Distributed - OpenTSDB

Formats variables with multiple values in custom format for OpenTSDB.

servers = ['test1', 'test2']
String to interpolate: '${servers:distributed}'
Interpolation result: 'test1,servers=test2'

`doublequote`

Formats single- and multi-valued variables into a comma-separated string, escapes " in each value by \" and quotes each value with ".

servers = ['test1', 'test2']
String to interpolate: '${servers:doublequote}'
Interpolation result: '"test1","test2"'

Glob - Graphite

Formats variables with multiple values into a glob (for Graphite queries).

servers = ['test1', 'test2']
String to interpolate: '${servers:glob}'
Interpolation result: '{test1,test2}'

Join

Formats multi-valued variables with a custom delimiter. If no delimiter argument is supplied, they’re combined with ,.

servers = ["test1", "test2"]
String to interpolate: '${servers:join:&}'
Interpolation result: "test1&test2"

JSON

Formats variables with multiple values as a comma-separated string.

servers = ['test1', 'test2']
String to interpolate: '${servers:json}'
Interpolation result: '["test1", "test2"]'

Lucene - Elasticsearch

Formats variables with multiple values in Lucene format for Elasticsearch.

servers = ['test1', 'test2']
String to interpolate: '${servers:lucene}'
Interpolation result: '("test1" OR "test2")'

`percentencode`

Formats single and multi valued variables for use in URL parameters.

servers = ['foo()bar BAZ', 'test2']
String to interpolate: '${servers:percentencode}'
Interpolation result: 'foo%28%29bar%20BAZ%2Ctest2'

Pipe

Formats variables with multiple values into a pipe-separated string.

servers = ['test1.', 'test2']
String to interpolate: '${servers:pipe}'
Interpolation result: 'test1.|test2'

Query parameters

Formats single- and multi-valued variables into their query parameter representation. Example: var-foo=value1&var-foo=value2

servers = ["test1", "test2"]
String to interpolate: '${servers:queryparam}'
Interpolation result: "var-servers=test1&var-servers=test2"

Use the customqueryparam formatter to customize how the query parameters are formatted. It accepts two optional arguments to specify the parameter name, and a value prefix.

servers = ["test1", "test2"]
String to interpolate: '${servers:customqueryparam:v-servers:x-}'
Interpolation result: "v-servers=x-test1&v-servers=x-test2"

Raw

Doesn’t apply any data source-specific formatting to the variable.

For example, in this case, there’s a dashboard with a Prometheus data source and a multi-value variable. Grafana typically converts the variable values as follows to accommodate Prometheus:

servers = ['test1.', 'test2']
String to interpolate: '${servers}'
Interpolation result: '(test1 | test2)'

Using the raw format, the values are returned without that formatting:

servers = ['test1.', 'test2']
String to interpolate: '${servers:raw}'
Interpolation result: 'test1,test2'

Regex

Formats variables with multiple values into a regular expression string.

servers = ['test1.', 'test2']
String to interpolate: '${servers:regex}'
Interpolation result: '(test1\.|test2)'

`singlequote`

Formats single- and multi-valued variables into a comma-separated string, escapes ' in each value by \' and quotes each value with '.

servers = ['test1', 'test2']
String to interpolate: '${servers:singlequote}'
Interpolation result: "'test1','test2'"

`sqlstring`

Formats single- and multi-valued variables into a comma-separated string, escapes ' in each value by '' and quotes each value with '.

servers = ["test'1", "test2"]
String to interpolate: '${servers:sqlstring}'
Interpolation result: "'test''1','test2'"

Text

Formats single- and multi-valued variables into their text representation. For a single variable it just returns the text representation. For multi-valued variables it returns the text representation combined with +.

servers = ["test1", "test2"]
String to interpolate: '${servers:text}'
Interpolation result: "test1 + test2"

Manage and inspect variables

Tue, 23 Jun 2026 13:06:40 +0000

Manage and inspect variables

In the Variables tab, you can add variables and manage existing variables. You can also inspect variables to identify any dependencies between them.

Manage variables

You can take the following actions in the Variables tab:

Move: Move a variable up or down the list using drag and drop.
Clone: Clone a variable by clicking the clone icon in the set of icons on the right. This creates a copy of the variable with the name of the original variable prefixed with copy_of_.
Delete: Delete a variable by clicking the trash icon in the set of icons on the right.

Inspect variables

In addition to managing variables, the Variables tab lets you quickly identify whether variables have any dependencies. To check, click Show dependencies at the bottom of the list, which opens the dependencies diagram:

Variables on Grafana Labs

Add variables

Add variables

Enter general options for any variable

Variable best practices

Add a query variable

Query type

Add a custom variable

Add a text box variable

Add a constant variable

Add a data source variable

Add an interval variable

Interval variable examples

Add a switch variable

Switch variable examples

Variable selection options

Multi-value variables

Multi-value variables with a Graphite data source

Multi-value variables with a Prometheus or InfluxDB data source

Multi-value variables with an Elastic data source

Variable indexing

Troubleshoot multi-value variables

Custom all value

Include All option

Global variables

Global variables

$__dashboard

$__from and $__to

$__interval

$__interval_ms

$__name

$__org

$__user

$__range

$__rate_interval

$__rate_interval_ms

$timeFilter or $__timeFilter

$__timezone

$__url_time_range

Advanced variable configurations

Advanced variable configurations

Multi-property variables

Multi-property custom variables

Multi-property query variables

Chained variables

Grafana Play dashboard examples

Graphite example explained

app variable

server variable

More variables

InfluxDB example explained

datacenter variable

host variable

More variables

Best practices for chained variables

New linked variables creation

Variable order

Complexity consideration

Filter variables with regular expressions

Filter to return only the options that end with 01 or 02

Filter and modify the options using a regular expression to capture group to return part of the text

Filter and modify: Prometheus Example

Filter and modify using named text and value capture groups

Variable syntax

Variable syntax

Advanced variable format options

General syntax

CSV

Distributed - OpenTSDB

doublequote

Glob - Graphite

Join

JSON

Lucene - Elasticsearch

percentencode

Pipe

Query parameters

Raw

Regex

singlequote

`$__dashboard`

`$from` and `$to`

`$__interval`

`$__interval_ms`

`$__name`

`$__org`

`$__user`

`$__range`

`$__rate_interval`

`$__rate_interval_ms`

`$timeFilter` or `$__timeFilter`

`$__timezone`

`$__url_time_range`

`app` variable

`server` variable

`datacenter` variable

`host` variable

Filter to return only the options that end with `01` or `02`

`doublequote`

`percentencode`

`singlequote`

`sqlstring`