Pack value to bytes: pack

The pack template function converts a value into a bytes object using a Python struct format string. This is the same as Python’s struct.pack function, allowing you to convert numbers and other values into their binary representations according to a specified format.

This function is primarily useful for IoT and low-level device communication. Many IoT devicesA device is a model representing a physical or logical unit that contains entities. communicate using binary protocols where you need to send data in a specific byte format. For example, you might need to send a temperature value as a big-endian 16-bit integer to a Bluetooth device, or pack a command byte sequence for an MQTT-connected microcontroller. The format strings follow Python’s struct module syntax.

Usage

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

{{ pack(1234, ">H") }}

b''\x04\xd2''

{{ 1234 | pack(">H") }}

b''\x04\xd2''

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.

pack(
    value: Any,
    format_string: str,
) -> bytes | None

Function parameters

The following parameters can be provided to this function.

Common format strings

Here are the format strings you will reach for most often. The > prefix means big-endian (most significant byte first) and < means little-endian (least significant byte first).

• >B: big-endian unsigned byte (1 byte)
• >H: big-endian unsigned short (2 bytes)
• >I: big-endian unsigned int (4 bytes)
• >f: big-endian float (4 bytes)
• <H: little-endian unsigned short (2 bytes)
• <i: little-endian signed int (4 bytes)

Good to know

• The value type must match the format specifier, or packing fails. >H expects an integer between 0 and 65535.
• Endianness matters. > is big-endian (network order) and < is little-endian.
• Returns raw bytes. For transmission over text channels, combine with base64_encode.

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.

Pack a temperature for a BLE device

Pack a temperature reading as a big-endian 16-bit integer for transmission to a Bluetooth Low Energy device.

{{
  states("sensor.temperature") | float | round(0) | int
  | pack(">H") | base64_encode
}}

ABU=

Pack a float value

Pack a floating-point number into its binary representation.

{{ 3.14 | pack(">f") }}

b'@H\xf5\xc3'

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.

Related template functions

These functions work well alongside this one:

• Unpack bytes to value: unpack - Unpacks bytes into a value using a Python struct format string.

• Decode hex string to bytes: from_hex - Decodes a hexadecimal string into bytes.

• Encode to base64: base64_encode - Encodes a string or bytes to a base64 string.