2026.10.4
Home ▸ Template functions

Get all repair issues: issues

The issues template function returns all current repair issues in Home Assistant. Repair issues are problems that Home Assistant has detected and flagged for your attention, such as deprecated integrations, configuration errors, or devices that need manual intervention. The result is a dictionary where each key is a (domain, issue_id) tuple and each value is a dictionary with the details of that issue.

This is useful for building dashboard cards or automationsAutomations in Home Assistant allow you to automatically respond to things that happen in and around your home. [Learn more] that monitor the health of your Home Assistant installation. For example, you might want to display a count of repair issues on your dashboard, send a notificationYou can use notifications to send messages, pictures, and more, to devices. [Learn more] when new issues appear, or create a template sensor that tracks whether any repairs are waiting for you.

Usage

Here’s how to use this template function. Copy any example and adjust it to your setup.

As a function 
{{ issues() | length }}
Result (integerA whole number without decimal places, like 1, 42, or -5. Used for counts, indices, and whole values.) 
3

Function signature

The signature is a technical summary of this template function. It shows the name of the function, the values (called parameters) it accepts, and what type of data each parameter expects (for example, a piece of text or a number).

Function parameters that have a = with a value after them are optional. If you leave them out, the default value shown is used automatically.

Function parameters without a = are usually required. A few optional parameters have no default value, so the signature shows them without a = as well. To check whether a parameter is required, look at the parameter list below the signature. Each parameter is marked as Required or Optional.

The most common optional parameter without a default value is default. The default parameter sets the value a function returns when the function can’t produce a result, for example, when float gets text that isn’t a number. If you leave out default, there is no fallback value, so most functions raise an error and the template fails. The parameter list of each function says what happens. If you set default, the function returns your value instead.

How to read a signature

Here is the signature of the round filter as an example:

round(
    value: Any,
    precision: int = 0,
    method: str = "common",
    default: Any,
) -> float | int | Any
  • round is the name of the function.
  • Between the parentheses are the parameters. Each parameter has a name, followed by a colon and the type of value the parameter expects. The type only tells you what kind of value to pass. For default: Any, you pass a value of any type, such as 0 or "unknown", not the word Any.
  • = 0 and = "common" are default values. You can leave out precision and method, and round uses these default values.
  • default has no =, but the parameter list marks default as optional. If you leave out default and round gets a value that isn’t a number, round raises an error.
  • -> shows the type of value the function returns.
  • Inside a signature, | means “or”. This function returns a decimal number, a whole number, or the value you passed as default.

round is a filter, so the first parameter, value, is the value before the |. For example, {{ 3.14159 | round(2) }} returns 3.14.

The types you’ll see most often:

  • str: text, such as "hello"
  • int: a whole number, such as 5
  • float: a decimal number, such as 3.14
  • bool: true or false
  • list: a list of values, such as [1, 2, 3]. list[str] is a list of texts.
  • dict: a set of keys and values, such as {"name": "Kitchen"}
  • datetime and timedelta: a date and time, and a duration. For details, refer to Dates and times.
  • None: no value
  • Any: any type of value

Some signatures use special forms:

  • *args means you can pass any number of values, separated by commas. For example, average(1, 2, 3).
  • value | name(...) means the function is a filter. The value before the | is passed to the filter as its first parameter. Some filter signatures, like the round example, show this value as the first parameter between the parentheses instead.
issues() -> dict[tuple[str, str], dict[str, Any]]

Function parameters

This function takes no parameters. It returns all current repair issues.

Understanding repair issues

Repair issues are created by integrationsIntegrations connect and integrate Home Assistant with your devices, services, and more. [Learn more] when they detect a problem that needs your attention. This function returns the same issues you see in Settings > System > Repairs, including the ones you ignored. Every issue contains these keys:

  • domain: The integration that created the issue.
  • issue_id: The unique identifier for the issue within the domain.
  • created: When the issue was first raised, as an ISO 8601 timestamp string.
  • dismissed_version: The Home Assistant version in which you ignored the issue, or None if you haven’t ignored it.
  • config_entry_id: The ID of the integration entry that raised the issue, or None if the issue isn’t tied to an entry.
  • is_persistent: Whether Home Assistant keeps the issue across restarts.

Most issues are not persistent. Only persistent issues (where is_persistent is true) also include details like severity, translation_key, translation_placeholders, learn_more_url, and breaks_in_ha_version. When severity is present, it is critical, error, or warning. The Repairs page shows a severity for every issue, but templates only get severity for persistent issues.

TemplateA template is an automation definition that can include variables for the action or data from the trigger values. This allows automations to generate dynamic actions. [Learn more]: List all issues 
{% for issue in issues().values() %}
  {{ issue.domain }}: {{ issue.issue_id }}
{% endfor %}
Result (stringA piece of text, like a name, message, or entity ID. In templates, wrap strings in quotes, like "living_room" or "lights are on".) 
backup: automatic_backup_failed
zwave_js: invalid_server_version

Good to know

  • Returns a dictionary keyed by a (domain, issue_id) tuple, not a plain list.
  • Issues you ignored are included. An ignored issue has a dismissed_version, so filter on that key if you only care about issues you haven’t ignored.
  • Issues from integration entries you disabled are not included.
  • Details like severity are only available for persistent issues, so filtering on severity skips most issues.

Try it yourself

Ready to test this? Open Settings > Tools > Template, paste the example into the Template editor, and watch the result update on the right. Edit the values to see how the function adapts to your own entitiesAn entity represents a sensor, actor, or function in Home Assistant. Entities are used to monitor physical properties or to control other entities. An entity is usually part of a device or a service. [Learn more].

More examples

Real scenarios where this function comes up in automations and templates. Copy any example and adapt it to your setup.

Count all issues

Display the total number of repair issues on a dashboard, including the ones you ignored.

TemplateA template is an automation definition that can include variables for the action or data from the trigger values. This allows automations to generate dynamic actions. [Learn more] 
{% set all_issues = issues() %}
{{ all_issues | length }} repair issue{{ "s" if all_issues | length != 1 }}
Result (stringA piece of text, like a name, message, or entity ID. In templates, wrap strings in quotes, like "living_room" or "lights are on".) 
3 repair issues

Skip ignored issues

Count only the issues you haven’t ignored.

TemplateA template is an automation definition that can include variables for the action or data from the trigger values. This allows automations to generate dynamic actions. [Learn more] 
{% set open_issues = issues().values()
  | rejectattr("dismissed_version") | list %}
{% if open_issues | length > 0 %}
  {{ open_issues | length }} open issue{{ "s" if open_issues | length != 1 }}
{% else %}
  All clear
{% endif %}
Result (stringA piece of text, like a name, message, or entity ID. In templates, wrap strings in quotes, like "living_room" or "lights are on".) 
2 open issues

Still stuck?

The Home Assistant community is quick to help: join Discord for real-time chat, post on the community forum with your template and expected result, or share on our subreddit /r/homeassistant.

Tip

AI assistants like ChatGPT or Claude can also explain or fix templates when you describe what you want in plain language.

Related template functions

These functions work well alongside this one: