Round a number: round

The round filter rounds a numeric value to a specified number of decimal places. It is a Home Assistant override of the standard round filter that adds support for a default parameter and the half rounding method. When rounding to zero decimals, it returns an integer instead of a float.

Rounding is essential whenever you display sensorSensors return information about a thing, for instance the level of water in a tank. [Learn more] values on a dashboard or in a notification. A temperature of 21.456789 is not useful on a dashboard; 21.5 is much better. Similarly, you might want to round energy costs to two decimal places, or display a percentage as a whole number. The round filter supports four rounding methods to cover different use cases, from standard rounding to always rounding up or down.

Usage

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

As a filter
{{ states("sensor.temperature") | float(0) | round(1) }}
Result (floatA number that can have decimal places, like 21.5 or 3.14. Used for temperatures, percentages, and other measurements that need precision.)
21.5

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 default are required.

round(
    value: Any,
    precision: int = 0,
    method: str = "common",
    default: Any = _SENTINEL,
) -> float | int | Any

Function parameters

The following parameters can be provided to this filter.

value any Required

The value to round. Must be a number or a string that can be converted to a float.

precision integer (Optional, default: 0)

The number of decimal places to round to. Defaults to 0, which returns an integer.

method string (Optional, default: “common”)

The rounding method to use. One of common, ceil, floor, or half. Defaults to common.

default any (Optional)

Value to return if the conversion fails. If not provided, an error is raised on invalid input.

Rounding methods

The round filter supports four rounding methods:

Common (default)

The default method uses Python’s built-in rounding, which follows the “round half to even” (banker’s rounding) strategy. Values exactly halfway between two numbers are rounded to the nearest even number.

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]: Round to 1 decimal
{{ 21.456 | round(1) }}
Result (floatA number that can have decimal places, like 21.5 or 3.14. Used for temperatures, percentages, and other measurements that need precision.)
21.5
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]: Banker's rounding: 2.5 rounds to even
{{ 2.5 | round(0) }}
Result (integerA whole number without decimal places, like 1, 42, or -5. Used for counts, indices, and whole values.)
2

Ceil (always round up)

Always rounds up to the next value at the given precision.

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]: Always round up
{{ 21.1 | round(0, "ceil") }}
Result (integerA whole number without decimal places, like 1, 42, or -5. Used for counts, indices, and whole values.)
22

Floor (always round down)

Always rounds down to the previous value at the given precision.

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]: Always round down
{{ 21.9 | round(0, "floor") }}
Result (integerA whole number without decimal places, like 1, 42, or -5. Used for counts, indices, and whole values.)
21

Half (round to nearest 0.5)

Rounds the value to the nearest 0.5 increment. This is useful for thermostats and other devicesA device is a model representing a physical or logical unit that contains entities. that operate in half-degree steps.

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]
{{ 21.3 | round(0, "half") }}
Result (floatA number that can have decimal places, like 21.5 or 3.14. Used for temperatures, percentages, and other measurements that need precision.)
21.5

Good to know

  • The default common method uses banker’s rounding, where 0.5 rounds to the nearest even number. So 2.5 | round gives 2, not 3.
  • With precision=0 (the default), the result is an integer. With a nonzero precision, the result is a float.
  • The half method rounds to the nearest 0.5 rather than the nearest whole number.

Try it yourself

Ready to test this? Open Developer 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.

Display a clean temperature value

Round a temperature sensor to one decimal place for display on a dashboard.

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]
{{ states("sensor.outdoor_temperature") | float(0) | round(1) }}
Result (floatA number that can have decimal places, like 21.5 or 3.14. Used for temperatures, percentages, and other measurements that need precision.)
18.3

Round up for resource planning

When calculating how many items you need, always round up so you don’t run short.

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]: Cans of paint needed (each covers 10 sqm)
{{ (states("sensor.paint_area") | float(0) / 10) | round(0, "ceil") }}
Result (integerA whole number without decimal places, like 1, 42, or -5. Used for counts, indices, and whole values.)
4

Round a cost to two decimals

Display an energy cost with exactly two decimal places.

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]
{{ (states("sensor.energy_today") | float(0) * 0.25) | round(2) }}
Result (floatA number that can have decimal places, like 21.5 or 3.14. Used for temperatures, percentages, and other measurements that need precision.)
3.47

Set a thermostat to the nearest half degree

Round a calculated target temperature to the nearest 0.5 so it matches what the thermostat accepts.

ActionActions are used in several places in Home Assistant. As part of a script or automation, actions define what is going to happen once a trigger is activated. In scripts, an action is called *sequence*. [Learn more]
action:
  - action: climate.set_temperature
    target:
      entity_id: climate.living_room
    data:
      temperature: >
        {{
          states("sensor.desired_temperature")
          | float(20) | round(0, "half")
        }}

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:

  • Convert to float: float - Converts a value to a floating-point number, with an optional default if conversion fails.

  • Convert to integer: int - Converts a value to an integer, with an optional default if conversion fails.

  • Multiply a value: multiply - Multiplies a numeric value by a specified amount, with an optional default if conversion fails.

  • Add to a value: add - Adds a specified amount to a numeric value, with an optional default if conversion fails.