InfluxData Blog - Community

Node-RED Dashboard Tutorial

Community (InfluxData) — Wed, 18 Feb 2026 08:00:00 +0000

If you’re already familiar with Node-RED, you know how useful it is for automation. This post is a guide to getting started with the Node-RED dashboard 2.0. We’ll cover how to install the Node-RED dashboard 2.0 nodes and provide examples of how to create a graphical user interface (GUI) for your automation.

What is Node-RED?

Node-RED is a programming tool built on Node.js that lets you create automated workflows with minimal code. It wires different nodes together, with each node performing a specific function that links them to create a flow that carries out an automation task (e.g., switching off the light in a room or closing a door).

Prerequisites

We assume you’ve already installed and set up Node-RED. If that isn’t the case, here are some guides that can help you achieve that a few different ways:

Node-RED dashboard installation

The first step in the process is installing the dashboard module in Node-RED.

In the browser’s Node-RED window, click on the Menu icon at the top right corner of the page, find Manage Palette on the menu items, click Install, and search for @flowfuse/node-red-dashboard. Install it and make sure the module reads @flowfuse/node-red-dashboard.

After successful installation, all the Dashboard 2.0 nodes will appear in the palette section. Each dashboard node provides a widget that you can display in a user interface (UI) (e.g., a gauge, chart, or button).

Creating a user interface

In this section, we’ll walk through how to create a dashboard UI using the Dashboard 2.0 nodes on Node-RED. But first, let’s understand the dashboard hierarchy.

Dashboard Hierarchy

Dashboard 2.0 uses this hierarchical structure:

Base: Defines the base URL for your dashboard. The default is /dashboard.
Page: Individual pages that users can navigate to.
Theme: Offers different options for styling the dashboard.
Group: Collections of widgets within a page
Widget: Individual UI elements, like buttons, text, charts, and others.

We use pages and groups to arrange the UI in the Node-RED Dashboard 2.0. Pages are the main navigation section that hold or display different groups, which separate a page into several sections. In each group, you organize your node widgets (buttons, texts, charts, etc.)

Now let’s create your first widget.

Step 1: Grab a button node

Look at your palette on the left side and find the button node (It’s in the dashboard 2 section). Click and drag it to your workspace (the big grid area in the middle of your screen).

Step 2: Open the configuration

Double-click on the button you just placed. A configuration window will pop up with a bunch of options.

Step 3: Create a group

See Group near the top? Click the pencil icon next to the dropdown. This edits the default group Node-RED created when you added the widget. Give it a name like “My Controls.” If you want to create a completely new group instead, click the plus sign next to the pencil icon.

Step 4: Create a page

Now, in that same group window, you’ll see a field that says Page. Click the pencil icon next to it and then give the page a name, maybe “Dashboard,” for your first one. Now click Add ( or Update if you’re editing the default, as in my case).

Step 5: Finish up

You’ll be back at the group window. Click Add (or Update) there as well, and you should be returned to the button configuration window. Click Done, and everything should be set.

Now we have successfully created our first page and group. The next step will be displaying something on the user interface.

In this example, we want to create a button that displays text when clicked on.

Add a text node from your palette and place it near your button.
Wire them together. You can do this by dragging from the button’s right port to the text node’s left port.

Double-click the text node and set the Group to match your button’s group (in my case, “My Controls”). Also, give a name and a label, then click Done.

Next, double-click the button, scroll to Payload, type “Welcome to Dashboard 2.0!”, enter a name and a label like “Click Me,” and click Done.
Now click the red Deploy button in the top right corner.

To view the dashboard UI, follow this URL: http://localhost:1880/dashboard or http://Your_RPi_IP_address:1880/dashboard, where Your_RPi_IP_address is the address of the Raspberry Pi machine you’re using, 1880 is the port where Node-RED is exposed, and /dashboard displays the dashboard user interface.

If everything works correctly, you’ll see the same window shown below.

When you click the button, the “Welcome to Dashboard 2.0” text will appear as shown in the image below.

You might see a light theme background. We’ll get to how to change themes later in the post.

More examples of widgets

Let’s create a simple dashboard example with two tabs and UI elements (widgets) in each.

Creating Additional Pages

Open the Dashboard 2.0 sidebar (right side of your editor) and click the + Page button at the top.

This will create a new page and pop up a window with options to edit the page’s properties (such as name, path, and others). Remember, you can also create pages when configuring a widget (as we did earlier).

Building an interactive data visualization

Now, we’ll create a slider that controls both a gauge and a chart in real-time. This is the setup:

Step 1: Drag a slider, gauge, and chart node into your workspace. Step 2: Double-click the slider, set min to 0, max to 100, and assign to a new group on your second page, which you just created (mine is “Monitoring Dashboard”).

Step 3: Next, double-click the gauge. Assign it to the same group and range of 0-100, and add a color segment (green 0-30, yellow 30-70, red 70-100).

Step 4: Next, configure the chart. Same group and set Type to “Line.”

Step 5: After this, you need to wire the gauge and chart to the slider, as shown in the image below.

Step 6: Deploy and go to your dashboard UI (http://localhost:1880/dashboard or http://Your_RPi_IP_address:1880/dashboard). Step 7: In your dashboard UI, navigate to the next page. Click the hamburger icon in the top left corner, and you will see a list of your pages. Select your second page (mine is “Monitoring Dashboard”).

Step 8: On your second page, notice the initial state of your dashboard.

Step 9: Move the slider on your dashboard and watch everything update instantly (the gauge changes color, the chart plots, and Z the values).

Connecting to real weather data

Now, let’s enhance our example by connecting to a real data source. In this example, we would fetch real weather data and display it on our dashboard.

Step 1: Go to your Manage Palette on your Menu, search and install node-red-node-openweathermap (Like we did with @flowfuse/node-red-dashboard in the previous example).

Step 2: Get an API Key from http://openweathermap.org (New keys take up to two hours to activate, so be patient if you’re just signing up).

Step 3: Drag openweathermap node to your workspace, double-click it, paste your API key and enter your city and country (e.g., “New York City, US”), and then click Done.

Step 4: Next, drag an inject node to your workspace, double-click it, and set Repeat to “interval.” Also, check “Inject once after” so it runs on startup. Then wire the inject node to your openweathermap node.

Step 5: Drag a debug node, wire it to the openweathermap node, and Deploy. Open the Debug panel (in the right sidebar, bug icon). You’ll see the weather data structure showing what’s available.

Step 6: Next, add three function nodes to extract data:

Double-click the first function node, name it “Get Temperature,” and add the code below:

msg.payload = msg.payload.tempc; 
return msg;

Name the second “Get Humidity” and add:

msg.payload = msg.payload.humidity; 
return msg;

Name the last function “Get Conditions” and add:

msg.payload = msg.payload.description;
return msg;

Wire all three functions from the openweathermap node.

Step 7: Next, add display widgets:

Add two gauge nodes for temperature (set unit as “°C”, range -10 to 40) and humidity (% as unit, range 0-100).
Add one text node for the weather conditions.
Assign all to the same group (preferably a new group and page) and wire each function to its corresponding display widget.

Step 8: Finally, deploy and visit your dashboard UI.

Now, you’ve gotten a live weather dashboard updating every 10 minutes!

Dashboard theme and styling

By default, the Node-RED dashboard comes with a light theme, but you can also customize it. To edit the theme on your UI, open the Dashboard 2.0 sidebar, click on the Theme section, and you can:

Customize themes and colors
Set custom fonts
Adjust spacing and sizing

After you’re done, don’t forget to deploy so you can view your changes.

Common issues and fixes

While following this tutorial, here are some common hurdles you might encounter and how to fix them:

If your dashboard fails to open, look at the URL. Try using http://localhost:1880/dashboard, otherwise, use your PI’s IP instead.
If your widgets are not appearing on your dashboard, ensure that they’re connected to a group and a page before deploying.
If OpenWeatherMap returns “Invalid API key,” just wait a bit (activation can last two hours). Clicking buttons, but no response? Ensure your nodes are well-connected.

Wrapping up Node-RED dashboard

The aim of this guide was to provide basic knowledge of how the Node-RED dashboard 2.0 works on Raspberry Pi. I believe, with all the examples we covered in this post, you should have an idea of what you want to do next with the Node-RED dashboard on your journey to an automated life.

Node-RED Dashboard FAQs

What is the difference between Node-RED Dashboard 1.0 and Dashboard 2.0?

Dashboard 2.0, published by FlowFuse under the package @flowfuse/node-red-dashboard, is a ground-up rewrite of the original Node-RED dashboard. It introduces a new hierarchy (Base, Page, Theme, Group, Widget), improved theming and styling controls, and a more modern component set. If you're starting a new project, Dashboard 2.0 is the recommended choice, as it is actively maintained and better suited for complex, multi-page UIs.

Can I run the Node-RED dashboard without a Raspberry Pi?

Yes. Node-RED runs on any system that supports Node.js, including Windows, macOS, and Linux. The dashboard is accessed through a browser at http://localhost:1880/dashboard regardless of which machine Node-RED is installed on. Raspberry Pi is a popular choice for home automation projects, but it is not required to use the Node-RED dashboard.

Why are my Node-RED dashboard widgets not showing up?

The most common reason widgets don't appear is that they haven't been assigned to both a Group and a Page before deploying. Every widget in Dashboard 2.0 must be linked to a group, which must itself be linked to a page. Double-click the widget node to verify those assignments, then click the red Deploy button and refresh your dashboard URL.

How do I display live data from an external API in the Node-RED dashboard?

Use an inject node set to a repeating interval to trigger the flow on a schedule, then connect it to a data-source node (such as node-red-node-openweathermap for weather data). Wire one or more function nodes after the data source to extract the specific fields you need from the payload, then connect each function node to a corresponding display widget — such as a gauge or text node — on your dashboard. Deploy the flow and the dashboard will update automatically at each interval.

How do I add multiple pages to my Node-RED dashboard?

Open the Dashboard 2.0 sidebar on the right side of the Node-RED editor and click the + Page button to create a new page. You can also create a page directly when configuring any widget node — click the pencil icon next to the Page field to edit or create one inline. Once pages are created, users can navigate between them via the hamburger menu in the top-left corner of the dashboard UI.

How do I change the theme or colors of my Node-RED dashboard?

In the Dashboard 2.0 sidebar, navigate to the Theme section. From there you can customize colors, set custom fonts, and adjust spacing and sizing. The default is a light theme, but dark and custom themes are supported. After making changes, click Deploy to apply them to your live dashboard.

What types of widgets are available in Node-RED Dashboard 2.0?

Dashboard 2.0 includes a range of UI widgets covering inputs (buttons, sliders), displays (gauges, charts, text), and layout controls (groups, pages). Gauges support color-coded segments, charts support line and other types, and sliders can drive real-time updates to other widgets. All widgets appear in the palette under the "dashboard 2" section after installing @flowfuse/node-red-dashboard.

Exponential Smoothing: A Guide to Getting Started

Community (InfluxData) — Tue, 03 Feb 2026 08:00:00 +0000

Exponential smoothing is a time series forecasting method that uses an exponentially weighted average of past observations to predict future values. In other words, it assigns greater weight to recent observations than to older ones, allowing the forecast to adapt to changing data trends.

In this post, we’ll look at the basics of exponential smoothing, including how it works, its types, and how to implement it in Python.

What is exponential smoothing?

Exponential smoothing forecasts time series data by smoothing out fluctuations in the data. The technique was first introduced by Robert Goodell Brown in 1956 and then further developed by Charles Holt in 1957. It has since become one of the most widely used methods for forecasting.

The basic idea behind exponential smoothing is to give more weight to recent observations by assigning weights to each observation that decrease exponentially with age. Weights are then used to calculate a weighted moving average of the data, which is used to forecast the next period.

Exponential smoothing assumes that future values of a time series are a function of its past values. The method works well when the time series has a trend and/or a seasonal component, but it can also be used for stationary data (i.e., without trend or seasonality).

Types of exponential smoothing

There are several types of exponential smoothing methods, each with its own formulae and assumptions. The most commonly used methods include:

1. Simple Exponential Smoothing

Simple exponential smoothing (SES), also known as single exponential smoothing, is its simplest form. It assumes that the time series has no trend or seasonality.

The forecast for the next period is based on the weighted average of the previous observation and the forecast for the current period.

The formula for simple exponential smoothing is:

s_(t) = αx_(t) + (1-α)s_t-1

where

s_(t) is the smoothed value at time t,
x_(t) is the observed value at time t,
s_t-1 is the previous smoothed statistic, and
α is the smoothing parameter between 0 and 1.

The smoothing parameter α controls the weight given to the current observation and the previous forecast.

A high value of α gives more weight to the current observation, while a low value of α gives more weight to the previous forecast.

2. Holt’s Linear Exponential Smoothing

Holt’s linear exponential smoothing, also known as double exponential smoothing, is used to forecast time series data that has a linear trend but no seasonal pattern. This method uses two smoothing parameters: α for the level (the intercept) and β for the trend.

The formulas for double exponential smoothing are:

s_t = αx_t + (1 – α)(s_t-1 + b_t-1)

β_t = β(s_t – s_t-1) + (1 – β)b_t-1

where

bt is the slope and best estimate of the trend at time t,
α is the smoothing parameter of data (0 < α < 1), and
β is the smoothing parameter for the trend (0 < β < 1).

Holt’s method is more accurate than SES for time series data with a trend, but it doesn’t work well for time series data with a seasonal component.

3. Holt-Winters’ Exponential Smoothing

Holt-Winters’ exponential smoothing, also referred to as triple exponential smoothing, is used to forecast time series data with both a trend and a seasonal component. It uses three smoothing parameters: α for the level (the intercept), β for the trend, and γ for the seasonal component.

The triple exponential smoothing formulas are given by:

where:

s_t = smoothed statistic; it’s the simple weighted average of current observation Y_t
s_t-1 = previous smoothed statistic
α = smoothing factor of data (0 < α < 1)
t = time period
b_t = best estimate of a trend at time t
β = trend smoothing factor (0 < β <1)
c_t = seasonal component at time t
γ = seasonal smoothing parameter (0 < γ < 1)

Holt-Winters’ method is the most accurate of the three methods, but it’s also the most complex, requiring more data and computation than the other methods.

When to use exponential smoothing

Exponential smoothing is most useful for time series data that has a consistent trend, seasonality, and random fluctuations.

It’s particularly useful for short to medium-term forecasting of business metrics such as sales, revenue, and customer traffic. It’s also useful for monitoring and predicting seasonal changes in industries such as tourism, agriculture, and energy.

Here are some other common situations where exponential smoothing can be useful:

Time series forecasting — One of the most common applications of exponential smoothing is in time series forecasting. If you have historical data for a particular variable over time, such as sales or website traffic, you can use exponential smoothing to forecast the future values of that variable.
Inventory management — Exponential smoothing can be used to forecast demand for products or services, which can be helpful in inventory management. By forecasting demand, businesses can make sure they have enough inventory on hand to meet customer needs without overstocking.
Finance — It can be used in finance to forecast stock prices, interest rates, and other financial variables. This can be helpful for investors who are trying to make informed decisions about buying and selling stocks or other financial instruments.
Marketing — It’s also used to forecast the effectiveness of marketing campaigns. By tracking past campaign results and using exponential smoothing to forecast future performance, marketers can optimize their campaigns to achieve the best possible results.

Why is exponential smoothing popular?

Exponential smoothing is among the most widely used time series forecasting methods due to its simplicity and effectiveness.

Unlike other methods, exponential smoothing can adapt to changes in data trends. It also provides accurate predictions by assigning different weights to different time periods based on their importance.

Exponential smoothing is computationally efficient, making it ideal for large datasets. Additionally, it’s widely used in business forecasting, providing accurate, reliable forecasts across a range of applications, including demand, sales, and financial forecasting.

How to perform exponential smoothing

Performing exponential smoothing begins with understanding your data’s structure.

First, examine your time series to identify whether it contains trends, seasonality, or neither. This analysis will guide you in selecting the right exponential smoothing method: SES works best for stationary data, Holt’s method handles data with trends, and Holt-Winters’ method addresses both trends and seasonal patterns.

Once you’ve chosen your method, the implementation is straightforward. Modern statistical software and libraries can automatically optimize the smoothing parameters (α, β, and γ) by finding values that minimize forecast errors.

After fitting the model to your historical data, you’ll have a trained forecasting tool ready to generate predictions for future time periods.

Now, let’s put this into practice by implementing exponential smoothing using Python, one of the most popular tools for time series analysis.

Exponential smoothing in Python

Python has several libraries for exponential smoothing, including Pandas, Statsmodels, and Prophet. These libraries provide various functions and methods for implementing different types of exponential smoothing methods.

The Dataset

For this example, we’ll use the AirPassengers dataset, a time series dataset that contains the monthly number of airline passengers from 1949 to 1960. You can download the dataset from this link.

Setting Up the Environment

To get started, we need to set up our environment. We’ll be using Python 3, so make sure it’s installed. Alternatively, you can use Google Colab and go straight to importing the libraries.

Next, install these libraries using pip:

pip install pandas matplotlib statsmodels

Once you’ve installed the necessary libraries, you can import them into your Python script:

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.api import SimpleExpSmoothing

Loading the Data

After setting up the environment, we can load the AirPassengers dataset into a pandas DataFrame using the read_csv function:

data = pd.read_csv('airline-passengers.csv', parse_dates=['Month'], index_col='Month')

We can then inspect the first few rows of the DataFrame using the head function:

print(data.head())

This will output:

Visualizing the Data

Before we apply simple exponential smoothing to the data, let’s visualize it to get a better understanding of its properties. We can use the plot function of pandas to create a line plot of the data:

plt.plot(data)
plt.xlabel('Year')
plt.ylabel('Number of Passengers')
plt.show()

This will produce a plot of the number of passengers over time:

We can see that the number of passengers appears to be increasing, with some seasonality as well.

Performing SES

Now that we’ve loaded and visualized the data, we can perform simple exponential smoothing using the SimpleExpSmoothing function from the statsmodels library. Then, we’ll create an instance of the SimpleExpSmoothing class, passing in the data as an argument, and then fit the model to the data using the fit method:

model = SimpleExpSmoothing(data)
model_fit = model.fit(optimized=True)
print(model_fit.summary())

This will calculate the smoothing parameters and fit the model to the data. The optimized=True parameter allows the model to find the best smoothing parameter (α) for your data.

Making Predictions

Finally, we can use the forecast method to predict future values of the time series, where the argument specifies the number of periods to forecast.

forecast = model_fit.forecast(6)
print(forecast)

This will produce a forecast for the next six months:

Based on the forecast, we can assume that over the next six months, there will be approximately 432 airline passengers.

Wrapping up

Exponential smoothing is a powerful method for time series forecasting that allows for accurate predictions of future values based on past observations. It’s a simple, efficient method that can be used for a wide range of time series data.

In this post, we provided a beginner’s guide to exponential smoothing, explaining the basics of the method, its types, and how to use it for forecasting. However, there are more advanced techniques and approaches to discover beyond the scope of this post.

If you’re interested in learning more, be sure to check out this Python time series forecasting tutorial. It’s a great resource that can help you deepen your understanding of this topic and take your forecasting skills to the next level with InfluxDB.

Exponential smoothing FAQs

What is the smoothing parameter α in exponential smoothing and how do I choose it?

The smoothing parameter α (alpha) controls how much weight is given to the most recent observation versus older data. A value close to 1 makes the forecast highly responsive to the latest data point, while a value close to 0 places more emphasis on the historical average. In practice, you don't need to set α manually — libraries like Python's statsmodels can automatically optimize α by minimizing forecast error when you use the optimized=True parameter.

What is the difference between simple, double, and triple exponential smoothing?

Simple exponential smoothing (SES) works best for stationary data with no trend or seasonality, using a single smoothing parameter α. Double exponential smoothing (Holt's method) adds a second parameter β to handle data with a linear trend. Triple exponential smoothing (Holt-Winters' method) adds a third parameter γ to also capture seasonal patterns, making it the most accurate of the three but also the most computationally demanding.

How do I know which exponential smoothing method to use for my data?

Start by plotting your time series and examining its structure. If the data is relatively flat with no clear upward/downward drift or repeating seasonal cycles, use Simple Exponential Smoothing. If there's a consistent trend but no seasonality, use Holt's linear method. If both a trend and seasonal pattern are visible — such as sales data that peaks every holiday quarter — use Holt-Winters' method. The key is to visually inspect your data before selecting a model.

Is exponential smoothing the same as a moving average?

They are related but not the same. A simple moving average gives equal weight to all observations in the window and completely ignores data outside it. Exponential smoothing, on the other hand, uses all historical data but assigns weights that decrease exponentially with age — meaning the most recent observations have the greatest influence. This makes exponential smoothing more adaptive to recent changes than a standard moving average.

What Python libraries can I use for exponential smoothing?

The most commonly used library is statsmodels, which provides SimpleExpSmoothing for SES and ExponentialSmoothing for Holt's and Holt-Winters' methods. You'll also typically use pandas for loading and preparing your time series data and matplotlib for visualizing it. All three can be installed via pip and work well together for end-to-end forecasting workflows in Python.

What are the limitations of exponential smoothing?

Exponential smoothing is best suited for short to medium-term forecasting and assumes that future patterns will resemble past ones. It struggles with abrupt structural changes in the data, such as sudden market shifts or one-time events, because the model adapts gradually. It also doesn't capture complex non-linear relationships between multiple variables. For longer-horizon forecasts or multivariate scenarios, models like ARIMA, SARIMA, or machine learning-based approaches may be more appropriate.

How accurate are exponential smoothing forecasts?

Forecast accuracy depends on how well the chosen method matches your data's structure. When the right variant is applied — SES for stationary data, Holt's for trended data, Holt-Winters' for seasonal data — exponential smoothing consistently delivers strong results for short to medium-term horizons. Accuracy also improves when smoothing parameters are automatically optimized to minimize error on your historical data, as supported by statsmodels' optimized=True option.

This post was written by Israel Oyetunji. Israel is a frontend developer with a knack for creating engaging UI and interactive experiences. He has proven experience developing consumer-focused websites using HTML, CSS, JavaScript, ReactJS, SASS, and relevant technologies. He loves writing about tech and creating how-to tutorials for developers.

Getting Started with InfluxDB and Pandas: A Beginner's Guide

Community (InfluxData) — Tue, 27 Jan 2026 08:00:00 +0000

InfluxData prides itself on prioritizing developer happiness. A key ingredient to that formula is providing client libraries that let users interact with the database in their chosen language and library. Data analysis is the task most broadly associated with Python use cases, accounting for 58% of Python tasks, so it makes sense that Pandas is the second most popular library for Python users. The InfluxDB 3 Python client library supports Pandas DataFrames, making it easy for data scientists to use InfluxDB.

In this tutorial, we’ll learn how to query our InfluxDB instance and return the data as a DataFrame. We’ll also explore some data science resources included in the Client repo. To learn about how to get started with the InfluxDB 3 Python client library, please take a look at this video.

Me eagerly consuming Pandas and InfluxDB Documentation. Photo by Sid Balachandran on Unsplash.

Data science resources

A variety of data science resources have been included in the InfluxDB Python client repo to help you take advantage of the Pandas functionality of the client. I encourage you to take a look at the example notebooks.

Dependencies

pyarrow (automatically comes with influxdb3-python installation)
pandas
certifi (if you are using Windows)

Installations

pip install influxdb3-python pandas certifi

Import Dependencies


import influxdb_client_3 as influxDBclient3
import pandas as pd
Import certifi #if you are on Windows
from influxdb_client_3 import flight_client_options

Initialization

Direct Initialization

Take note that the “database” argument in the function is the bucket name if you are using InfluxDB cloud:

client = InfluxDBClient3(token="your-token",
                         host="your-host",
                         database="your-database or your bucket name")

For Windows Users

Include certifi within the “flight_client_options” argument within the client initialization to fix certificate issues:

with open(certifi.where(), "r") as fh:
    cert = fh.read()
client = InfluxDBClient3(token="your-token",
                         host="your-host",
                         database="your-database or your bucket name”,
flight_client_options=flight_client_options(tls_root_certs=cert)

Prepare a pandas Dataframe

Let’s use simple weather data:


# Example weather data
df = pd.DataFrame({
    "timestamp": pd.date_range("2025-09-01", periods=4, freq="h", tz="UTC"),
    "city": ["Lagos", "Illinois", "Chicago", "Abuja"],
    "temperature": [30.5, 15, 16, 32],
    "humidity": [20, 10, 10, 19]
})

# ensure timestamp dtype is datetime64[ns] and (optionally) timezone-aware
df['timestamp'] = pd.to_datetime(df['timestamp'], utc=True)
print(df.head())

Weather timestamp data.

Write the pandas Dataframe to InfluxDB


client._write_api.write(
    bucket="my_bucket",
    record=df,
    data_frame_measurement_name="weather",
    data_frame_tag_columns=["city", "temperature"],
    data_frame_timestamp_column="timestamp"
)
print("DataFrame written to bucket=new-test-bucket, measurement=weather")

Below is confirmation in your InfluxDB Cloud that the Pandas DataFrame was successfully written to the bucket.

Pandas Dataframe written to InfluxDB.

Query InfluxDB and return a Pandas DataFrame

query = "SELECT * FROM weather"
table = client.query(query=query, language="influxql")
result_df = table.to_pandas()

print("Loading from InfluxDB:")
print(result_df.head())

Returning a Pandas DataFrame from InfluxDB

Start building with InfluxDB and Pandas

InfluxDB makes it easy to integrate with your existing data analysis tools and frameworks, such as Pandas, to get insights from your time series data. Under the hood, you get the benefits of Apache Arrow for fast data transfers into Pandas DataFrames without any performance hits. Whether you’re building dashboards, machine learning models, or just exploring your metrics, combining InfluxDB 3 with Pandas gives you the best of both worlds in terms of performance and developer experience. As always, if you run into hurdles, please share them on our community site or Slack channel. We’d love to get your feedback and help with any problems you run into.

How to Integrate Grafana with Home Assistant in 2026

Community (InfluxData) — Thu, 08 Jan 2026 08:00:00 +0000

This post covers how to get started with Home Assistant and Grafana, including setting up InfluxDB and Grafana with Docker, configuring InfluxDB to receive data from Home Assistant, and creating a Grafana dashboard to visualize your data. It provides a comprehensive guide for real-time monitoring and analysis of Home Assistant data.

In this tutorial, you’ll learn how to install and configure both InfluxDB and Grafana, and create a Grafana dashboard to visualize data from Home Assistant.

Want to know more about InfluxDB and Grafana before you get started?

Watch the webinar.

Definitions: Grafana, Home Assistant, InfluxDB

Home Assistant

Home Assistant is an open source home automation platform that enables control and monitoring of various devices using a web interface or mobile app. With support for diverse devices and protocols, it’s highly customizable, allowing users to integrate new devices and protocols through custom components.

Grafana

Grafana is a versatile open source analytics and monitoring platform that offers powerful data visualization capabilities. It supports various data sources, including popular databases, such as InfluxDB, Elasticsearch, Prometheus, MySQL, PostgreSQL, and more.

With its extensibility through plugins, Grafana allows users to easily incorporate new data sources for enhanced analytics and monitoring.

InfluxDB

InfluxDB is an open source time series database designed for storing and querying time series data. It supports a wide range of data types, including integers, floats, strings, booleans, and others. Additionally, InfluxDB provides the flexibility to incorporate new data types via plugins.

Home Assistant integrates with Grafana, an analytics and monitoring platform, to visualize and analyze data. This data can be collected and stored in InfluxDB, an open source time series database, which allows for efficient querying of timestamped data.

Together, these tools enable users to control and monitor their smart home devices through Home Assistant while visualizing and analyzing the data in real-time using Grafana and InfluxDB.

Prerequisites and versions

To follow this tutorial, you will need the following:

Home Assistant 2025.1+
Docker 24.0+
InfluxDB 3.x
Grafana 12

Step 1: Install InfluxDB 3 Core

Option A: Install via Docker

First, pull the InfluxDB 3 image using this command:

docker pull influxdb:3-core

Once the download is complete, run the InfluxDB container with the following command:

docker run -d\
	--name influxdb \
	–p 8086:8086 \
-v influxdb3_data:/var/lib/influxdb2 \
	-v influxdb3_config:/etc/influxdb2 \
-e DOCKER_INFLUXDB_INIT_MODE=setup \
     -e DOCKER_INFLUXDB_INIT_USERNAME=admin \
     -e DOCKER_INFLUXDB_INIT_PASSWORD=your_password \
     -e DOCKER_INFLUXDB_INIT_ORG=home_org \
     -e DOCKER_INFLUXDB_INIT_BUCKET=home_assistant \
     influxdb:3

This command starts InfluxDB on port 8086, configures an initial user, organization, and bucket, and stores data in Docker volumes so it survives container restarts.

Option B: Install Directly

First, you’ll need to install InfluxDB on your machine. You can find instructions for your specific operating system on the InfluxDB downloads page.

Step 2: Configure InfluxDB and Generate an API Token

After installing InfluxDB, you’ll need to configure it to accept data from Home Assistant. You can do this by creating a new InfluxDB database and user account.

Open your browser and navigate to http://localhost:8086.

If you used the environment variables in Step 1, you can log in with the username and password you specified. Otherwise, complete the initial setup process.

Next, generate an API Token by:

In the InfluxDB UI, click Load Data in the left sidebar
Click API Tokens
Click Generate API Token (All Access API Token)
Give it a description like “Home Assistant Token”
Grant Write permission to the home_assistant bucket
Click Generate

Lastly, copy and save the token, as you’ll need it for Home Assistant and Grafana configuration.

Step 3: Configure the InfluxDB integration in Home Assistant

Now, you’ll need to install the InfluxDB integration in Home Assistant. You can do this by navigating to the Home Assistant web interface, selecting Settings from the sidebar, and then selecting Integrations. From there, you can search for InfluxDB and follow the prompts to configure the integration. Next, open your Home Assistant configuration.yaml file and add the following influxdb configuration block:

 influxdb:
     api_version: 2
     ssl: false
     host: YOUR_INFLUXDB_IP
     port: 8086
     token: YOUR_API_TOKEN
     organization: home_org
     bucket: home_assistant
     tags:
       source: HomeAssistant
     tags_attributes:
       - friendly_name
     default_measurement: state
     exclude:
       entity_globs:
         - sensor.date*
         - sensor.time*
     include:
       domains:
         - sensor
         - binary_sensor
         - climate
         - light
         - switch

Then, restart Home Assistant to apply the changes.

For additional configuration options, see the Home Assistant InfluxDB integration documentation.

Verify Data is Flowing to InfluxDB

After restarting Home Assistant:

Return to the InfluxDB UI
Click the Data Explorer in the left sidebar
Select your home_assistant bucket
Within a few minutes, you should see measurements appearing

If you don’t see data, check the logs at Settings -> System -> Logs for connection errors.

Step 4: Install Grafana Using Docker

If you prefer to run Grafana in Docker rather than install it locally, follow these steps.

Install Docker

If you haven’t already, you’ll need to install Docker on your machine. You can find instructions for your specific OS on the Docker website.

Pull the Grafana Docker Image

Once Docker is installed, you can pull the Grafana Docker image by running the following command in your terminal:

docker pull grafana/grafana

This will download the latest version of the Grafana Docker image to your machine.

Run the Grafana Docker container

To start a new Grafana Docker container, run the following command in your terminal:

docker run -d -p 3000:3000 --name=grafana grafana/grafana

This will start a new container named grafana and map port 3000 on the container to port 3000 on your local machine.

Access the Grafana web interface

Once the container is running, you can access the Grafana web interface by navigating to http://localhost:3000 in your web browser.

Create a Grafana account and connect data sources

When you first access the Grafana web interface, you’ll be prompted to create a new user account. After creating your account, you can start configuring Grafana by adding a data source and creating dashboards, as described in the previous steps.

Configure Grafana

After installing Grafana, you’ll need to configure it to connect to the InfluxDB database. You can do this by following these steps:

Open the Grafana web interface by navigating to http://localhost:3000 in your web browser. Log in to Grafana using the default username admin and password admin.

Click on the Configuration icon in the sidebar and select Data Sources.
Click on the Add data source button and select InfluxDB. Enter the following information in the InfluxDB details section:
- URL: http://localhost:8086
- Query Language: SQL or InfluxQL
- Database: homeassistant
- User: homeassistant
- Password: yourpassword
- HTTP method: GET
Click on the Save & Test button to save the data source and test the connection to InfluxDB.

Create a Grafana dashboard

After configuring the InfluxDB data source in Grafana, you can create a new dashboard to visualize the Home Assistant data. To do this, follow these steps:

Click the Create icon in the sidebar, then select Dashboard.
Click on the Add new panel button and select Graph.
Click on Panel title.
In the Query tab, select the InfluxDB data source that you configured.
Enter your InfluxDB query in the Query editor. For example, you might enter a query like this to display the temperature from a temperature sensor:

SELECT mean("value") FROM "temperature" WHERE ("entity_id" = 'sensor.temperature') AND $timeFilter GROUP BY time($__interval)

This query selects the average temperature from the temperature measurement for the sensor.temperature entity in Home Assistant and groups the results by time interval.

Click on the Apply button to save the query and display the results.

Customize your panel as desired by selecting different visualization options, adding legends and annotations, etc.

Click on the Save icon in the toolbar to save the panel to your dashboard.

You can repeat these steps to add more panels to your dashboard, using different InfluxDB queries to display different data. Check InfluxDB’s Grafana documentation for more details.

Step 8: View Your Dashboard

After creating your Grafana dashboard, you can view it by navigating to http://localhost:3000/dashboards in your web browser and selecting the dashboard from the list. You should now see a visual representation of your Home Assistant data in Grafana!

Troubleshooting and FAQs

No data appears in InfluxDB after configuring Home Assistant

Check your Home Assistant logs (Settings > System > Logs). If the connection fails, you will see errors there. Ensure the token in configuration.yaml is correct and wrapped in quotes if it contains special characters.

Can I write to multiple InfluxDB databases or buckets from Home Assistant?

No. Home Assistant’s InfluxDB integration only supports writing to a single database or bucket. All your sensor data must be sent to a single location. If you need to separate data streams, you’ll need to use Home Assistant’s filtering options in configuration.yaml to exclude certain entities, or run multiple Home Assistant instances.

My Grafana can’t connect to InfluxDB even though both are running. What’s wrong?

This is often a Docker networking issue. If both services are running in Docker containers, they may not be able to reach each other via localhost.

Try using your host machine’s actual IP address (like 192.168.1.100:8086) instead of localhost:8086 in Grafana’s data source configuration. Also, verify that the port number matches; InfluxDB’s HTTP API uses port 8086 by default.

If you’re using Home Assistant add-ons, make sure you’re using the correct internal container names (like a0d7b954-influxdb:8086 instead of a0d7b954_influxdb:8086, note the hyphen vs underscore).

Can I use InfluxDB Cloud instead of running my own instance?

Yes. InfluxDB Cloud offers a fully-managed InfluxDB 3 service, and the setup is very similar. You’ll get a URL, organization, bucket, and API token from the InfluxDB Cloud console, then configure Home Assistant and Grafana to point at those cloud endpoints instead of a local instance.

This eliminates the need to manage Docker containers, backups, and updates yourself. However, you’ll need to consider data egress costs if you have high query volumes, and your Home Assistant data will be stored in the cloud rather than locally.

Can I migrate from InfluxDB 2.x to 3.x?

Yes, InfluxDB 3 maintains backward compatibility with the v2 write API. Your Home Assistant configuration will continue to work. For data migration, refer to the official InfluxDB migration documentation.

Next steps for Home Assistant and Grafana

Getting started with Home Assistant and Grafana requires installing InfluxDB and Grafana on your machine, configuring InfluxDB to accept data from Home Assistant, installing the InfluxDB integration in Home Assistant, configuring Grafana to connect to the InfluxDB database, and creating a Grafana dashboard to visualize your data. With these tools and techniques, you can easily monitor and analyze your Home Assistant data in real-time.

A Guide to Regression Analysis with Time Series Data

Community (InfluxData) — Tue, 06 Jan 2026 08:00:00 +0000

Regression analysis with time series data in Python provides a basis for understanding how values change over time. By following this guide, you’ll understand regression as applied to time series data, how to prepare it in Python, and how to create regression models that’ll help discover trends and influence decisions.

With the vast amount of time series data generated, captured, and consumed daily, how can you make sense of it? This data is projected to triple to more than 180 zettabytes by 2029.

By using regression analysis with time series data, we can gain valuable insights into the behavior of complex systems over time, identify trends and patterns, and make informed decisions based on our analysis and predictions.

This post serves as a guide to regression analysis with time series data in Python. By the end, you should know what time series data is and how to use it with regression analysis.

What is time series data?

Time series data records each observation at a specific point in time and at regular intervals. In time series data, the order of observations matters, and you use the data to analyze changes or patterns.

Examples of this type of data include stock prices, weather measurements, economic indicators, and many others. Time series data is widely used across finance, economics, engineering, and social sciences.

The critical difference between time series data and other data types, such as categorical and numerical, is time. This component allows us to spot trends and makes predictive analysis possible.

What is regression and regression analysis?

Regression is a statistical technique you use to explore and model the relationship between a dependent variable (the response variable) and one or more independent variables (the predictor or explanatory variables).

Regression analysis involves estimating the coefficients of the regression equation, which describe the relationship between the independent and dependent variables. There are several regression models, including linear, logistic, and polynomial regression. In each type, you’re trying to find the best-fit line or curve representing the variables’ relationship.

Like time series data, you’ll find regression analysis in many fields, including economics, finance, social sciences, and engineering, to understand the underlying relationships between variables and to make predictions based on those relationships.

Can you run a regression on time series data?

Yes, you can run a regression on time series data. In time series regression, the dependent variable is a time series, and the independent variables can be other time series or non-time series variables.

Time series regression helps you understand the relationship between variables over time and forecast future values of the dependent variable.

Some common application examples of time series regression include:

predicting stock prices based on economic indicators
forecasting electricity demand based on weather data
estimating the impact of marketing campaigns on sales

There are various statistical techniques available for time series regression analysis, including Autoregressive Integrated Moving Average (ARIMA) models, vector autoregression (VAR) models, and Bayesian structural time series (BSTS) models, among others.

What are the steps in time series regression analysis?

This guide assumes that you’ve set up your environment. But to follow along, you’ll need Python, Data Package, NumPy, Matplotlib, Seaborn, pandas, and statsmodels.

Data Collection and Preparation

The first step in regression analysis is to collect the data. Time series data is collected over a specific period and includes variables that change over time, ensuring that the data is accurate, complete, and consistent is essential.

Once you’ve collected the data, prepare for analysis by removing any outliers, handling missing data, and transforming the data as needed.

In our case, we’ll use gas price data, and we’ll need to import some libraries. We’ll be using Pandas for data handling, Statsmodels for regression analysis, Matplotlib for data visualization, NumPy for numerical operations, and the Data Package to retrieve the data.

import statsmodels.api as sm
import datapackage
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

We’ll then load the time series data into a pandas dataframe. Our data is natural gas price data from 1997.

data_url = 'https://datahub.io/core/natural-gas/datapackage.json'

# to load Data Package into storage
package = datapackage.Package(data_url)

# to load only tabular data
resources = package.resources
for resource in resources:
    if resource.tabular:
        data = pd.read_csv(resource.descriptor['path'])
        print (data)

Since we’re working with time series data, we need to convert the data into a time series format. We can do this by setting the index of the DataFrame to the datetime format.

data['Month'] = pd.to_datetime(data['Month'])
data.set_index('Month', inplace=True)

Visualization

Before conducting regression analysis, it’s essential to visualize the data. You can use line graphs, scatter plots, or other graphical representations.

This helps identify trends, patterns, or relationships between the dependent and independent variables.

To do this, create a line plot of the data:

plt.plot(data)
plt.xlabel('Year')
plt.ylabel('Gas Price')
plt.show()

Model Specification and Estimation

The next step is to specify the regression model by selecting the dependent variable, identifying the independent variables, and choosing the model’s functional form. The model must account for the time component in time series data, including seasonal patterns, trends, and cyclical fluctuations.

Once you’ve specified the model, estimate it using statistical software. The most common method for time series regression analysis is ordinary least squares (OLS).

The software will estimate the model coefficients, which represent the strength and direction of the relationship between the dependent and independent variables.

Here, we’re using a simple linear regression model with one independent variable. We’ll use the gas price from the previous month as the independent variable and the gas prices for the current month as the dependent variable.

X = data['Price'].shift(1)
y = data['Price']

Before estimating the model, we need to split the data into training and testing sets. We’ll use the first 80% of the data for training the model and the remaining 20% for testing the model.

train_size = int(len(data) * 0.8)
train_X, test_X = X[1:train_size], X[train_size:]
train_y, test_y = y[1:train_size], y[train_size:]

Now, we can estimate the model using OLS regression from the statsmodels library.

model = sm.OLS(train_y, train_X)
result = model.fit()
print(result.summary())

Diagnostic

After estimating the model, it’s essential to assess model adequacy and identify any violations of the regression model’s assumptions.

This includes testing for autocorrelation, heteroscedasticity, and normality of residuals. These tests help ensure that the model is appropriate and reliable.

We can do this by plotting the residuals and conducting statistical tests.

residuals = result.resid
plt.plot(residuals)
plt.xlabel('Year')
plt.ylabel('Residuals')
plt.show()
print(sm.stats.diagnostic.acorr_ljungbox(residuals, lags=[12], boxpierce=True))

Interpretation

Once you’ve estimated the model and conducted diagnostic tests, you interpret the results. This involves examining the coefficients of the independent variables and the statistical significance of those coefficients.

The interpretation should also include an assessment of the model’s overall fit, such as the R-squared and adjusted R-squared values.

Possible Forecast

Regression analysis with time series data enables you to forecast future values of the dependent variable. This involves using the estimated model to predict future values of the dependent variable based on the values of the independent variables.

For example, we can use our model to predict the next month’s value. We’ll do this by taking the last price value from the dataset as input(lag_1) and using our model to predict the next value.

last_value = data[“Price”].iloc[-1] 
next_value = result.predict([last_value])

This provides a basic forecast example, but you can improve it by adding multiple lags, rolling averages, or using advanced models like Seasonal Autoregressive Integrated Moving Average with Exogenous Regressors (SARIMAX).

It’s essential to note that the forecast’s accuracy depends on the quality of the data, the appropriateness of the model, and the validity of the assumptions.

How can you use regression analysis with time series data?

Regression analysis is valuable for analyzing time series data when there’s a temporal relationship between the dependent variable and one or more independent variables.

Some common scenarios for time series regression analysis include:

Forecasting: With time series regression analysis, you can forecast possible future values of a variable based on its past values and the values of other variables that influence it.
Trend analysis: Time series regression analysis can identify and analyze trends in the data over time, including long-term trends, seasonal patterns, and cyclic patterns.
Impact analysis: You can use time-series regression to examine the impact of specific events or interventions on the time series, such as policy changes, natural disasters, or economic shocks.

Regression analysis with time series data is a potent tool for understanding relationships between variables. It’s a key component for understanding data in various industries, including finance, healthcare, and retail, among others.

By mastering the basics of regression analysis with time series data, you can unlock the power of your data and make informed decisions.

Time series regression analysis FAQs

What is regression analysis with time series data?

Regression analysis with time series data is a statistical technique used to explore the relationship between a dependent variable and one or more independent variables recorded over time. It allows analysts to identify trends, understand how variables interact across time periods, and forecast future values. Common applications include predicting stock prices, forecasting energy demand, and estimating the impact of marketing campaigns on sales.

Can you run a regression on time series data?

Yes, regression can be run on time series data. In time series regression, the dependent variable is a time series, while independent variables can be other time series or non-time series variables. Techniques such as ARIMA, vector autoregression (VAR), and Bayesian structural time series (BSTS) models are commonly used for this type of analysis.

What is the difference between time series data and other data types?

The key difference is the time component. Time series data records each observation at a specific point in time and at regular intervals, meaning the order of observations matters. This temporal structure allows analysts to detect trends, seasonal patterns, and make predictive forecasts — capabilities that are not inherent in categorical or standard numerical data.

What are the steps in time series regression analysis?

The main steps are: (1) data collection and preparation — cleaning, handling missing values, and formatting the data; (2) visualization — plotting the data to identify trends and patterns; (3) model specification and estimation — selecting variables and fitting the model, typically using ordinary least squares (OLS); (4) diagnostics — testing for autocorrelation, heteroscedasticity, and normality of residuals; (5) interpretation — reviewing coefficients and model fit; and (6) forecasting — using the model to predict future values.

How do you perform time series regression analysis in Python?

To perform time series regression in Python, you'll need libraries including pandas, NumPy, Matplotlib, Seaborn, and statsmodels. Load your data into a pandas DataFrame, convert the date column to datetime format and set it as the index, then use statsmodels.api.OLS to fit a regression model. Split your data into training and test sets before fitting, and use result.predict() to generate forecasts.

What is ordinary least squares (OLS) and when is it used in time series regression?

Ordinary least squares (OLS) is the most common method for estimating regression model coefficients. It works by finding the line or curve that minimizes the sum of squared differences between observed and predicted values. In time series regression, OLS is used to estimate the strength and direction of the relationship between independent and dependent variables across time periods.

What diagnostic tests should you run after fitting a time series regression model?

After fitting a time series regression model, you should test for autocorrelation (whether residuals are correlated over time), heteroscedasticity (whether variance of residuals is consistent), and normality of residuals. The Ljung-Box test is a common method for checking autocorrelation. Plotting residuals over time is also a useful visual check to identify any systematic patterns that suggest the model can be improved.

What are common use cases for regression analysis with time series data?

Common use cases include forecasting (predicting future values based on historical data and related variables), trend analysis (identifying long-term patterns, seasonal cycles, and cyclical fluctuations), and impact analysis (measuring the effect of specific events like policy changes or economic shocks on a time series). Industries using these techniques include finance, healthcare, retail, economics, and engineering.

Python ARIMA Tutorial 2026

Community (InfluxData) — Tue, 30 Dec 2025 08:00:00 +0000

Time series forecasting is an essential part of data analysis in fields such as finance, weather prediction, and sales forecasting, among others. The ARIMA model—a statistical method well known for its efficiency in estimating and forecasting time-dependent data—is a major topic in this domain. It is loved by many because it accurately models a variety of time series, making it a powerful tool in predictive analytics.

This guide will break down implementing ARIMA models in Python, a language with rich libraries and tools for data analysis. The simplicity and extensive support Python offers make it suitable for use with complex statistical models like ARIMA.

We’ll start by setting up your Python environment and building, evaluating, and optimizing ARIMA models. By the end of this post, you should be able to grasp the ARIMA model clearly and understand how to apply it for effective forecasting with Python.

What is ARIMA?

The AutoRegressive Integrated Moving Average (ARIMA) is a fundamental tool in time series analysis. It examines past values to understand and predict points within a data sequence. This model is particularly useful when dealing with data that changes over time. It consists of three key parts:

1. AutoRegression (AR)

This represents how much one variable depends on previous variables. AR estimates future values based on past observations; it looks at the relationship between a variable and its prior values.

2. Integration (I)

These are contrary operations that remove trends or seasonality from the data so that their mean and variance are constant over time. Basically, this means differencing the data (i.e., subtracting the previous value from the current value).

3. Moving Average (MA)

This incorporates errors that occurred previously, taking a combination of past errors into account while modeling them. It can be used to mitigate data noise and identify its underlying trend.

ARIMA parameters (p, d, q)

p denotes the AutoRegressive order. That is the number of lags in a model. For example, if p = 2, then the model uses two previous time points to predict the current value.
d is the degree of differencing required to make the data stationary (one with a constant mean and variance over time). Say d=1, then you’ll subtract the previous value from the current at least once; otherwise, if d = 0, then the data is stationary.
q shows the order of the moving average, which is the residual errors on MAs applied to lagged observations.

When to use ARIMA

The ARIMA model is widely applicable in real-life scenarios. As a result, it is ideal for modeling data with trends and seasonality, such as:

Economic forecasting: Predicting GDP, unemployment rates, or stock prices
Sales forecasting: Forecasting future product demand based on previous sales data
Weather forecasting: Temperature, rainfall, or other weather condition predictions
Resource allocation: Forecasting inventory or production needs in industries such as retail and manufacturing

Python offers a range of libraries for implementing ARIMA, such as statsmodels, which provides numerous features for building and analyzing models. Thus, Python is an effective tool for learning about ARIMA models and practically applying them.

Prerequisites

Here’s what you’ll need to follow along with this tutorial:

Basic Knowledge

Python proficiency: Familiarity with basic Python programming
Statistical understanding: Fundamental aspects of statistics, especially relevant to time series data

Tools and Libraries

Python: The primary language for implementation
Jupyter Notebook: An interactive coding experience
Key libraries: pandas, NumPy, matplotlib, statsmodels (pip installable)

Setting up your environment for ARIMA in Python

Installing Jupyter Notebook

Open the command line or terminal: Go to the command line (Windows) or terminal (Mac/Linux).
Install Jupyter: Type pip install notebook and press enter to install Jupyter Notebook on your computer.

Installing Python libraries

The following steps guide you through installing the Jupyter Notebook. To open the Jupyter Notebook, type jupyter notebook in your command line or terminal and press enter, as mentioned below.

Create a new notebook: In the Jupyter interface, create a new notebook for your ARIMA project.
Install libraries in notebook: Type and run the following commands in separate cells:
!pip install pandas for data manipulation
!pip install numpy for numerical operations
!pip install matplotlib for data visualization
!pip install statsmodels for statistical modeling, including ARIMA

These steps ensure you have a functional Python environment with all the necessary tools to start working with ARIMA models.

Implementing your first ARIMA model in Python

Importing Necessary Libraries

Start by importing the libraries you’ll need. In your Python environment (such as a Jupyter Notebook), enter the following commands:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.tsa.stattools import adfuller

Loading and Visualizing Time Series Data

We’re going to use this data from Kaggle.

Load data: Use pandas to load your time series data. For instance, you can use data = pd.read_csv(‘data.csv’).
Visualize data: Plot your data to understand its pattern. Here’s an example:

data.plot()
plt.show()

Testing for Stationarity

Stationarity is crucial for ARIMA models. Use the augmented Dickey-Fuller test to check for stationarity:

result = adfuller(data['column_name'])
print('ADF Statistic: %f' % result[0])
print('p-value: %f' % result[1])

If p-value > 0.05, the data are non-stationary and require differencing.

Differencing If Necessary

If your data is non-stationary, difference it:

data_diff = data.diff().dropna()

Determining ARIMA Parameters (p, d, q)

Plotting: Use plots (like autocorrelation and partial autocorrelation plots) to estimate ‘p’ and ‘q’.
Statistical tests: Use statistical methods or rules of thumb to find optimal ‘p’, ‘d’, ‘q’ values.

Building and Fitting an ARIMA Model

Create and fit an ARIMA model with your chosen parameters (here we’ve chosen 1 for all parameters):

model = ARIMA(data_diff, order=(1,1,1)) 
model_fit = model.fit()

Making Predictions

Use the fitted model to make forecasts:

predictions = model_fit.forecast(steps=5)  # Predict next 5 points
print(predictions)

Check Residuals

Plot to see the distribution of residuals:

model_fit.plot_diagnostics(figsize=(10,6))
plt.show()

How to evaluate an ARIMA model

Once you have programmed the ARIMA model in Python, it’s essential to evaluate its performance. Knowing how well your model fits the data aids in precise forecasting.

Understanding Performance Metrics

Akaike Information Criterion (AIC): This is a measure of how good a model is. It evaluates the relationship between the model’s complexity and how well it fits the data. The best value for AIC is minimal.
Bayesian Information Criterion (BIC): Similar to AIC, this method assesses quality but penalizes complex models more strongly than AIC. The best value for BIC is minimal.
Root Mean Square Error (RMSE): This metric gives an average error size. It is derived by taking the square root of mean-squared differences between the prediction and the actual observation in cases where a lower rise implies better.

Interpreting the Model Summary

You can find a summary of the ARIMA model in the statsmodels library. These are some critical things to look at:

Coefficients: The importance of each feature relative to the dependent variables is revealed by these values.

Metric	Meaning
P > z	(p-values): Low p-values (usually < 0.05) imply that the parameters in this model are statistically significant.

AIC/BIC values: Use these to compare models.

Tuning your ARIMA model

To enhance forecasting accuracy, an ARIMA model needs its parameters (p, d, q) fine-tuned. The following are the appropriate steps to take.

Fine-Tuning Model Parameters (p, d, q)

Iterative approach: Test different combinations of p, d, and q based on initial analysis (such as ACF and PACF plots). For each combination, monitor the model’s performance and adjust accordingly.
Understand the data: Sometimes, through analyzing data, we get an idea of how much differencing is required (d) or the number of lag values to be included (p and q).
Simplicity matters: A simpler model that does well with fewer values of p, d, and q is often better than a complex one. Too many parameters result in overloading results.

Grid Search for Parameter Optimization

Grid search is the hand-specified examination of an entire space of hyperparameters. The main aim is to find the combination of p, d, and q that minimizes a metric or score.

Implementing Grid Search in Python

Here’s a simplified example of how to implement grid search for ARIMA model parameters in Python:

from statsmodels.tsa.arima.model import ARIMA
import itertools
# Define the p, d, and q ranges to try
p = range(0, 3)
d = range(0, 2)
q = range(0, 3)
pdq = list(itertools.product(p, d, q))
best_score, best_cfg = float("inf"), None
for param in pdq:
    try:
        model = ARIMA(train_data, order=param)
        model_fit = model.fit()
        # Adjust this to use your preferred metric (e.g., AIC)
        if model_fit.aic "" best_score:
            best_score, best_cfg = model_fit.aic, param
    except:
        continue

print('Best ARIMA%s AIC=%.2f' % (best_cfg, best_score))

The code will test different combinations of p, d, and q and identify the one with the smallest AIC (in case you prefer another criterion). Keep in mind that optimization may require considerable computer time when working with larger datasets and many possible parameter combinations.

ARIMA in Python: wrapping up

We’ve now walked through developing, implementing, and debugging the ARIMA model in Python. Like any worthwhile journey, there were tricky turns along the way, but the knowledge you received in the time series prediction arena is priceless.

Keep experimenting and learning from your data. Each dataset has a narrative, and you are now better placed to reveal these concealed stories. Have a great time forecasting!

Python ARIMA FAQs

What is the difference between ARIMA and SARIMA?

ARIMA (AutoRegressive Integrated Moving Average) models trends and non-seasonal patterns in time series data using three parameters: p (autoregressive order), d (differencing degree), and q (moving average order). SARIMA extends ARIMA by adding a seasonal component — it includes additional parameters (P, D, Q, m) to capture repeating cycles, such as monthly or quarterly patterns. If your data has no clear seasonality, ARIMA is sufficient; if seasonal patterns are present, SARIMA is the better choice.

How do I know if my time series data is stationary?

The most reliable method is the Augmented Dickey-Fuller (ADF) test, available in Python's statsmodels library via adfuller(). If the p-value returned is greater than 0.05, the data is non-stationary and needs differencing before you can fit an ARIMA model. You can also visually inspect the data by plotting it — a stationary series has a roughly constant mean and variance over time, with no clear upward or downward trend.

How do I choose the right p, d, and q values for my ARIMA model?

Start with d: run the ADF test and difference your data until it becomes stationary — the number of times you difference it is your d value. For p and q, plot the Partial Autocorrelation Function (PACF) to estimate p and the Autocorrelation Function (ACF) to estimate q. If you prefer an automated approach, use grid search with Python's itertools to systematically test combinations and select the one with the lowest AIC score.

What does AIC mean in ARIMA and why does a lower value indicate a better model?

AIC (Akaike Information Criterion) measures how well a model fits the data while penalizing unnecessary complexity. A lower AIC means the model explains the data well without overfitting by using too many parameters. When comparing multiple ARIMA configurations — for example during grid search — the model with the lowest AIC is generally the best balance between accuracy and simplicity. BIC (Bayesian Information Criterion) works similarly but applies a stronger penalty for complexity.

Can ARIMA handle data with multiple seasonal patterns?

Standard ARIMA is not designed for seasonal data and handles only a single differencing cycle at a time. For data with one seasonal pattern, SARIMA is recommended. For data with multiple overlapping seasonal cycles — for example, hourly data that has both daily and weekly patterns — more advanced methods such as TBATS or Facebook Prophet are typically better suited than ARIMA or SARIMA.

How do I check whether my ARIMA model's residuals are well-behaved?

After fitting your model, call model_fit.plot_diagnostics() from statsmodels to generate a four-panel diagnostic plot. Ideally, the residuals should look like white noise — randomly distributed around zero with no visible pattern. The histogram and Q-Q plot should resemble a normal distribution, and the correlogram should show no significant autocorrelation at any lag. If patterns remain in the residuals, it suggests the model has not fully captured the structure in your data and the parameters may need adjustment.

When should I use ARIMA instead of a machine learning model for forecasting?

ARIMA is a strong choice when your dataset is relatively small, you need an interpretable model, or your time series has a clear linear trend with limited external variables. It is computationally lightweight and well-suited for short to medium-term forecasting in domains like economic indicators, sales, and weather. Machine learning models such as LSTMs or gradient boosting tend to outperform ARIMA when you have large datasets, many input features, or complex non-linear relationships between variables.

This post was written by Keshav Malik, a highly skilled and enthusiastic security engineer. Keshav has a passion for automation, hacking, and exploring different tools and technologies. With a love for finding innovative solutions to complex problems, Keshav is constantly seeking new opportunities to grow and improve as a professional. He is dedicated to staying ahead of the curve and is always on the lookout for the latest and greatest tools and technologies.

Home Assistant Hardware in 2026: Requirements and Recommendations

Community (InfluxData) — Thu, 11 Dec 2025 08:00:00 +0000

Choosing the proper Home Assistant hardware can be overwhelming. Whether you’re new to home automation or a seasoned pro, the hardware you select can make or break your experience. This comprehensive guide will demystify the requirements, delve into the various options, and help you make an informed decision. From the compact Raspberry Pi to the powerful Intel NUC, we’ve got you covered. So, strap in, and let’s dive into the world of Home Assistant hardware!

What is Home Assistant?

If you’re unfamiliar with it, Home Assistant is an open source home automation platform that allows you to control all your smart home devices from one central hub. But before you start your journey to smart home nirvana, you must ensure you have the right hardware for what you want to accomplish.

Core hardware requirements for Home Assistant

Setting up your Home Assistant system doesn’t necessarily mean breaking the bank on high-end hardware. Home Assistant is designed to be versatile, and it can comfortably run on devices you might already have lying around. However, understanding the minimum requirements is crucial to ensuring a smooth and frustration-free experience. Let’s break it down.

At the minimum, you’ll want to hit the following specs for your hardware:

CPU	1.5GHz single-core processor
RAM	2GB
Storage	32GB
Network	Ethernet port or reliable WiFi

For a more responsive system that enables advanced analytics and automation and can extend over time, you will want to target the following:

CPU	Quad-core processor at 2GHz or higher
RAM	4-8GB or more
Storage	128GB SSD
Network	Gigabit ethernet

Architecture matters as well. While ARM processors (like those in Raspberry Pis) are energy-efficient and affordable, x86-64 processors offer better compatibility with add-ons and a generally superior performance. If you plan to run resource-intensive add-ons, such as Frigate for AI-powered camera detection or multiple database systems, you will also need more powerful hardware.

Home Assistant hardware options

Raspberry Pi

The Raspberry Pi is the poster child for affordable computing and is a popular choice for Home Assistant beginners. Here’s what you need to know:

Model: While it’s tempting to go for older, cheaper models, you’ll want at least a Raspberry Pi 3B. The 3B offers a good balance between cost and capability. However, if you can stretch your budget a bit, the Raspberry Pi 4 is even better, boasting faster processing and more RAM.The Raspberry Pi 5 has a 2.4GHz processor and improved I/O and can support NVMe storage with HAT adapters.
Power Supply: Ensure you have a reliable 5V/2.5A micro USB power supply for the Pi 3B and a USB-C power supply for the Pi 4. A stable power source prevents unexpected shutdowns and potential data corruption.
Heat Management: Raspberry Pis can get hot, especially when running continuously. Consider adding a heat sink or a fan to keep temperatures in check.

Odroid

Odroid single-board computers from Hardkernel offer a compelling middle ground between Raspberry Pi and full x86 systems. While less well-known, these Korean-made boards deliver superior performance and built-in eMMC storage for Home Assistant deployments.

Odroid-N2+: The flagship ARM board and top choice for demanding setups. Features a hexa-core processor (significantly faster than any Raspberry Pi), 2GB or 4GB RAM options, and built-in eMMC storage. Excellent thermal design keeps it stable under continuous load. Ideal for running resource-intensive add-ons like Frigate or managing 100+ devices.
Odroid-M1: The modern all-rounder with native M.2 NVMe slot (no adapters needed) and dual SATA ports for traditional drives. Available with 4GB or 8GB DDR4 RAM. Choose this if you prioritize storage flexibility and reliability. The quad-core RK3568 processor is efficient but less powerful than the N2+.
Odroid-C4: The Raspberry Pi alternative with a similar form factor but better reliability. Quad-core processor with 4GB RAM and eMMC support. Works well for mid-sized setups (50-75 devices) where you want better stability than Pi without the N2+ price tag.
Odroid-H3: The x86 option with Intel Celeron processor, dual M.2 slots, dual SATA ports, and support for up to 64GB RAM. Perfect for virtualization or when you need x86 compatibility.

NUC

If you’re thinking long-term and want a device that’s both compact and powerful, the Intel NUC might be your pick. Here’s a quick rundown:

Versatility: The Intel NUC series offers a range of configurations, from energy-efficient dual-core models to quad-core powerhouses. This means you can pick one that fits your needs and budget.
Expandability: Unlike the Raspberry Pi and Odroid-N2, the Intel NUC allows for upgrades. Whether it’s RAM or storage, you can expand as your Home Assistant setup grows.
Connectivity: With multiple USB ports, HDMI outputs, and even Ethernet, the Intel NUC ensures you’re always connected.

Home Assistant Green

Home Assistant Green is the official entry-level hardware, designed specifically for beginners starting with Home Assistant. Built around a Raspberry Pi Compute Module 4, it offers:

Pre-installed Home Assistant OS
32GB eMMC storage (more reliable than SD cards)
Built-in Zigbee coordinator
Compact, fanless design

Green is perfect for apartments or smaller homes with up to 50 devices. Its integrated Zigbee radio means one less USB device to manage, and the pre-installation eliminates setup complexity.

Home Assistant Yellow

Yellow targets enthusiasts who want official hardware with expansion capability:

Raspberry Pi Compute Module 4 (user-supplied)
M.2 slot for NVMe storage
Built-in Zigbee radio with external antenna
Power over Ethernet option
GPIO expansion headers

Yellow’s modular design lets you choose your CM4 variant based on needs and budget. The NVMe support ensures long-term reliability, while PoE capability enables clean installations without wall adapters.

Home Assistant storage deep dive

Storage can often be an afterthought in a smart home installation, with the temptation to choose the cheapest per-gigabyte option. But making a poor choice in storage can lead to all sorts of problems with regard to the usability and reliability of your Home Assistant setup. In this section, we’ll look at some of the options and general best practices for storage.

SD Cards

The traditional Pi storage medium is also its biggest weakness. Even high-endurance cards like SanDisk Extreme or Samsung Endurance eventually fail from constant writes. If you must use SD cards:

Buy high-endurance models rated for dashcams/surveillance
Implement aggressive recorder purging
Take regular backups
Plan for eventual failure

SSDs

SSDs are the gold standard for Home Assistant storage:

SATA SSDs provide excellent reliability and sufficient speed for all Home Assistant needs
NVMe drives offer peak performance but are overkill for most setups
Even budget SSDs vastly outperform SD cards in reliability External storage via USB 3.0 works well for Raspberry Pi users. USB-to-SATA adapters with SSDs provide near-native performance with better reliability than SD cards.

Backup Strategies

Backups are insurance against the inevitable hardware failure, corrupted SD card, or configuration mistake that breaks everything. The question isn’t whether you’ll need a backup, but when. A comprehensive backup strategy means the difference between restoring your smart home in minutes versus spending days rebuilding automations from memory. Let’s look at some options for creating backups with Home Assistant with increased levels of maturity.

Local backups: As a starting point, Home Assistant has automatic backup functionality built in that you can use to create snapshots on a set schedule. This allows you to roll back changes that break things like integrations or automations.
Network storage: The next step is moving your backups off the device running Home Assistant in case your hardware fails. Network-attached storage on your local network is a common strategy.
Cloud backups: The best option for backing up your data is to use cloud storage services to guarantee you can restore your system even if your entire local system fails. A combination of retention policies and scheduled backups can help reduce storage costs.

Database Management

Home Assistant’s default SQLite database works well for small installations but can become a bottleneck for certain use cases. If you plan to do analytics on your data or store it long term, you’ll want to use a dedicated database like InfluxDB. InfluxDB is designed to store the types of data commonly found in Home Assistant installations and is one of the most popular integrations in the Home Assistant ecosystem.

Power and reliability

Your smart home should work when you need it most. A UPS ensures operation during power outages or surges. To determine how large your UPS needs to be, you’ll want to calculate the power draw of the hardware you want to keep running and size it for at least 30 minutes of operation. For critical applications, consider the following redundancy strategies:

High availability	Home Assistant supports active/passive clustering, but requires careful planning and identical hardware.
Cold standby	Maintain a second, identical system with regular backup restoration tests. Switch manually during failures.
Hybrid	Run critical automations on dedicated hardware (like Hubitat or Shelly devices) with Home Assistant providing the interface and advanced logic.

How to choose the right hardware

Choosing the proper hardware for your Home Assistant setup isn’t just about meeting the minimum requirements, it’s about aligning those requirements with your specific needs. To recap everything covered in this blog, here is what you should keep in mind:

Assess Your Needs

Start by considering how you’ll use Home Assistant. Will it be a small setup with a few devices, or are you planning an extensive smart home system? The more complex your setup, the more powerful hardware you’ll need.

Plan a Budget

Budget plays a crucial role. Raspberry Pi is your go-to for a budget-friendly setup. Intel NUC or a dedicated server could be better options for a more extensive system, but they will be pricier.

Scalability

Think long-term. Your smart home will likely grow, so choose hardware that can accommodate future expansions.

Compatible Devices

Make sure to check compatibility. Home Assistant works with thousands of devices, from lights and thermostats to speakers and cameras. Compatibility shouldn’t be a significant concern, but it’s always good to double check.

Additional resources

FAQs

How do I know if my hardware is powerful enough?

Monitor your system metrics. If CPU regularly exceeds 50%, RAM usage stays above 80%, or automations feel sluggish, it's time to upgrade. The System Monitor integration provides detailed metrics.

What about running Home Assistant on Windows?

While possible via VirtualBox or WSL2, it's not recommended for production use. Linux-based installations (including Home Assistant OS) provide better stability and performance.

Which hardware is best for Home Assistant?

The "best" hardware depends on your specific needs and budget. For small setups, a Raspberry Pi 4 is excellent. For more extensive systems, consider an Intel NUC.

What hardware is needed for Home Assistant 2025?

A Raspberry Pi 3B or higher, Odroid-N2, or an old laptop with at least 2GB of RAM will work for running a basic Home Assistant installation.

How much RAM do I need for Home Assistant hardware?

A minimum of 2GB RAM is recommended for a basic setup. If you plan on running multiple add-ons and integrations, consider 4GB or more.

Is the Raspberry Pi 5 worth upgrading to from a Pi 4?

For most users, no. The Pi 4 remains highly capable for Home Assistant. Upgrade to Pi 5 if you need PCIe storage, run many add-ons, or your Pi 4 shows performance issues.

Can I run Home Assistant on my existing NAS?

Yes, if your NAS supports Docker or virtual machines. Synology, QNAP, and Unraid users report good success. However, dedicated hardware often provides better performance and stability.

Can I use a laptop as my Home Assistant server?

Old laptops make decent Home Assistant servers. Benefits include built-in battery backup and integrated screens. Downsides include higher power consumption and potential thermal issues.

9 Home Assistant Integrations You Should Be Using in 2026

Community (InfluxData) — Thu, 05 Jun 2025 08:00:00 +0000

With the advent of automation and smart devices, the adoption of home automation has increased.

The number of smart home users is projected to soar by about 86.5% between 2023 and 2027. Managing a smart home can get complicated, especially when dealing with multiple devices and platforms that don’t work together seamlessly. Navigating different interfaces and apps to control and monitor your devices can be time-consuming and confusing. Many of these devices and applications will also be generating time series data that you can utilize in a number of ways to make your Home Assistant more efficient and reliable while also enabling powerful automation.

However, Home Assistant integrations provide a powerful and flexible solution to these problems by allowing you to connect and control a wide range of smart home devices and platforms from a single interface.

This post will introduce you to Home Assistant and list nine Home Assistant integrations alongside ideas about how to use them. You will also learn how you can use these integrations with time series databases like InfluxDB to maximize the utility of your Home Assistant installation.

What is Home Assistant?

Home Assistant is an open source home automation platform for smart home devices and services. It allows you to control and automate a wide range of devices from a single interface, including lights, thermostats, cameras, and sensors.

With Home Assistant, you can create custom automation based on your needs. Custom automation can be triggered by various aspects, such as weather conditions or time of day.

Home Assistant can be installed on different devices and operating systems, including Raspberry Pi, macOS, Windows, and Linux. Additionally, you can integrate third-party services and platforms like Google Assistant.

You can also use community-developed add-ons that extend Home Assistant’s functionalities, giving you a robust home automation experience.

What are Home Assistant integrations?

Home Assistant integrations are add-ons or plugins that allow Home Assistant to communicate with other devices or services, such as smart home devices, platforms, and protocols. These tools make Home Assistant a powerful and flexible home automation platform.

Home Assistant has over 2,000 built-in integrations that cover a wide range of smart home devices and services, such as lights, switches, thermostats, sensors, media players, and more.

The Home Assistant community typically develops integrations that are open source and free to use.

Pairing Home Assistant with a time series database

Home Assistant provides a recorder integration that can be used for short-term logging and data storage, but this solution will become inefficient as you increase the amount of data you are storing or if you want to analyze your long-term data. A time series database is designed to handle large amounts of data from sensors, switches, thermostats, and other IoT devices. This enables you to monitor changes, identify patterns, and retain historical data far beyond what Home Assistant typically allows.

Beyond just storage, the integration of a time series database allows you to pair Home Assistant with visualization tools like Grafana to create intuitive dashboards and graphs. These dashboards offer deep insights into your smart home’s performance, including tracking energy consumption by device, monitoring temperature trends by room, and visualizing motion detection over time. This level of visibility empowers smarter decision-making and can even improve automation logic—for example, adjusting HVAC settings based on seasonal data or optimizing device usage during peak hours. Ultimately, a time series database turns Home Assistant from a reactive automation tool into a proactive, data-driven smart home hub.

Adding integrations to Home Assistant

To use an integration in Home Assistant, you need to install and configure it in the Home Assistant configuration file. The configuration process can vary depending on the integration but typically involves providing configuration details, such as credentials, API keys, or device IDs.

Once you’ve set up the integration, you can use Home Assistant to control and monitor the associated devices and services, create automation routines, and receive notifications and alerts.

You can access and manage integrations from the Home Assistant user interface. Depending on your needs, this makes adding, removing, and configuring integrations easy.

9 popular Home Assistant integrations

Below is a list of nine popular integrations you can add to your Home Assistant.

1. Weather Integration

The Weather integration in Home Assistant provides real-time weather data directly within your dashboard. By setting up your location, you can access current conditions, hourly forecasts, and extended outlooks.

Use this data to trigger weather-based automation, such as adjusting your thermostat when temperatures drop or notifying you of incoming storms. Multiple providers are supported, including OpenWeatherMap, AccuWeather, and the National Weather Service.

2. Z-Wave Integration

Z-Wave is a low-power wireless protocol designed specifically for smart home automation. Home Assistant’s Z-Wave JS integration allows you to add and control a wide variety of Z-Wave devices like lights, locks, sensors, and switches.

You’ll need a compatible Z-Wave USB stick or hub to get started. Once configured, you can include Z-Wave devices in automation, scenes, and routines—all managed locally and securely from Home Assistant.

3. HomeKit Integration

HomeKit is an Apple framework that allows you to control smart home devices using your Apple products.

The HomeKit integration connects your Home Assistant devices to your HomeKit ecosystem. To use this integration, you’ll need a HomeKit-enabled device, such as an iPhone or iPad, and the HomeKit integration set up in Home Assistant.

Once you’ve set up the integration, you can use your Apple devices to control your Home Assistant devices, such as turning on the lights or adjusting the thermostat.

4. Google Assistant Integration

Google Assistant is a virtual assistant by Google that can control smart home devices.

You’ll need a Google Assistant-enabled device, such as a Google Home or a smartphone with the Google Assistant app, to use this integration.

Once you’ve set up the integration, you can use voice commands to control your Home Assistant devices, such as turning on the lights or adjusting the thermostat.

5. MQTT Integration

MQTT (Message Queuing Telemetry Transport) is a lightweight, publish-subscribe protocol widely used in IoT systems. Home Assistant’s MQTT integration allows you to connect to a broker and communicate with DIY devices, microcontrollers, and third-party systems.

By configuring an MQTT broker (like Mosquitto), you can send and receive data from sensors, switches, and custom automation. This integration is ideal for advanced users looking to create a fully customized smart home environment.

6. Philips Hue Integration

Philips Hue is a smart lighting system that can be controlled with Home Assistant. To use this integration, you’ll need a Philips Hue bridge and some Philips Hue lights.

Once you’ve set up your Hue lights and bridge, you can use Home Assistant to turn your lights on and off, change their color and brightness, and create automation routines. For example, you can set an evening routine in which your lights are set to a warmer hue.

7. Sonos Integration

The Sonos integration lets you control your Sonos speakers from within Home Assistant. Play music, adjust volume, group speakers, or trigger playback based on motion or time-based automation.

With this integration, your Sonos ecosystem becomes a fully interactive part of your smart home, letting you sync music to lights, play alerts for door sensors, or announce weather updates in the morning.

8. Google Nest Integration

The Google Nest integration brings support for Nest thermostats, cameras, and doorbells into Home Assistant. After completing the account linking process, you can view live streams, adjust temperatures, or trigger automation based on motion or temperature events.

For example, set the thermostat to eco mode when no one is home or get notified if the doorbell camera detects motion after dark. It’s a powerful way to integrate your Nest devices into a broader automation ecosystem.

9. Tasmota Integration

Tasmota is open-source firmware for ESP8266/ESP32-based smart devices, often used to replace proprietary firmware on switches, plugs, and relays. Home Assistant’s Tasmota integration allows you to discover and manage these devices automatically.

Using MQTT or HTTP protocols, Tasmota devices can be easily controlled, monitored, and included in automation routines. This is a great option for privacy-conscious users who want reliable local control without depending on cloud services.

Why should you use InfluxDB with Home Assistant?

When you use InfluxDB with Home Assistant, you can collect, persist, analyze, and visualize data from your smart home devices over time. InfluxDB is the most popular database for Home Assistant, with over 7% of Home Assistant users installing the InfluxDB integration.

With the introduction of InfluxDB 3, the database has been completely reengineered to meet the modern demands of IoT and real-time analytics. It now supports high-ingest workloads, millisecond-level query responses, and object storage-based durability, making it ideal for smart home environments where large volumes of sensor data are continuously generated. InfluxDB 3’s new SQL-based query engine and native support for Parquet format also enable deeper, more complex queries for users who want to explore patterns or build advanced automations. InfluxDB 3 also includes a built-in Python engine that allows you to transform, process, and take action on your data without requiring external tools.

This architecture ensures that you can run InfluxDB Core on affordable local hardware for a single home setup—or scale to cloud or hybrid deployments with InfluxDB 3 Enterprise for larger or multi-site installations. Installing the InfluxDB integration in Home Assistant is straightforward:

Add your instance configuration to the YAML configuration file.
Define which entities or domains should report data to InfluxDB.

From there, you can easily forward information from devices like thermostats, humidity sensors, or energy meters—building a rich historical database of your smart home activity. With this dataset, you can create Grafana dashboards, optimize automation, detect anomalies, and gain long-term insights that wouldn’t be possible with Home Assistant’s default recorder.

Next steps and additional resources

Home Assistant is a powerful and flexible platform for managing and automating smart home devices and services. Its integrations cover a wide range of smart home devices and services, including lights, switches, thermostats, sensors, and media players.

Using Home Assistant integrations, you can streamline your home automation setup, reduce complexity and frustration, and gain more control and visibility into your smart home devices and services.

With Home Assistant and InfluxDB, you can take your home automation to the next level and create a brilliant and efficient living environment.

Here are some additional tutorials showing how you can use Home Assistant:

Home Assistant integration FAQs

How do I add a new integration in Home Assistant?

Integrations can be added to Home Assistant using the UI or the YAML configuration file. In the UI, you navigate to settings, then devices and services, and finally, the Add Integration section, where you can search for your desired integration. For certain advanced integrations, you will need to use YAML to set your configuration parameters.

What's the difference between using InfluxDB and the Home Assistant recorder?

The built-in Home Assistant recorder uses SQLite or other configured databases to store and retain data for a limited time at set intervals. InfluxDB scales better for larger datasets, offers faster query performance, and allows for easy creation of retention and downsampling policies.

What can I do with Home Assistant data stored in InfluxDB?

With InfluxDB, you can build monitoring dashboards with Grafana, analyze historical trends in your data, detect anomalies in the activity of your devices, and create automated alerts based on your data.

Do I need coding skills to use Home Assistant integrations?

Most integrations do not require coding, and Home Assistant's user interface makes it easy to add and manage them. However, some custom or community integrations may require light YAML editing or command-line usage.

Can Google Assistant or Amazon Alexa be used with Home Assistant?

Home Assistant supports both Google Assistant and Amazon Alexa integrations. These allow you to control your smart devices with voice commands by linking your Home Assistant instance with your Voice Assistant account.

What devices are compatible with Home Assistant?

Thousands of devices are compatible with Home Assistant, via direct integrations or common communication protocols like MQTT or Matter. Examples include smart lights, smart thermostats, switches and outlets, security systems, and various monitors or sensors.

Can Home Assistant work without an internet connection?

Home Assistant is designed to run locally, meaning it works even if your internet goes down. This ensures faster response times, increased reliability, and better privacy.

What is the difference between a Home Assistant integration and add-on?

Integrations connect Home Assistant to devices and services, while add-ons are additional applications like InfluxDB, Node-Red, or Grafana that run alongside Home Assistant.

Can I use Grafana with Home Assistant and InfluxDB?

Yes. Grafana connects directly to InfluxDB to create custom dashboards. Many users visualize trends like temperature, humidity, energy, or device activity over days, weeks, or months using Grafana's powerful charting tools.

This post was originally written by Mercy Kibet and later updated by InfluxData staff. Mercy is a full-stack developer with a knack for learning and writing about new and intriguing tech stacks.

Getting Started with Home Assistant and Docker

Community (InfluxData) — Tue, 03 Jun 2025 07:35:00 +0000

In this post, we’ll be looking at how to get started with Home Assistant and Docker. First, we’ll look at the prerequisites for getting Docker installed on your system depending on your OS, and run through how to install and run your Home Assistant on Docker using the CLI. Then, we’ll discuss solutions to common issues experienced during the installation process.

What is Docker?

Docker is a software platform that allows system administrators and developers to create, deploy, and run applications in containers. In this context, a container is an environment containing all the dependencies, libraries, code, system tools, and more that are required to run a specific application in the host OS. A container is created from an image, which is a template used to define what a container should contain.

Regardless of your system’s OS and infrastructure, Docker allows you to run any application in a specific environment. Plus, it makes it easy to manage and scale your environments. With Docker, building and deploying your applications become consistent and efficient.

What is Home Assistant?

Home Assistant is a flexible platform that allows you to control and automate your home devices, like your cameras, thermostats, lights, and sensors. It’s open source and fully integrated with over 1,000 services and devices, such as Amazon Alexa and Google Assistant. Home Assistant comes with a user-friendly, unified web-based user interface that allows you to create complex automation. Or, in another way, our home devices can also be interacted with using Python scripts via a built-in Python API in Home Assistant called Home Assistant Python API.

Home Assistant on Docker

Docker is a common way of running Home Assistant in a containerized environment. A key advantage of running Home Assistant on Docker is that the software is isolated from the host system and from other containers that might be running on the same host system. Furthermore, it’s very portable and consistent. The software can easily be moved from one host system to another, keeping the container environment completely intact as long as the target system has Docker installed. The ease of deploying your software is also very simple and secure.

Learn how to use Home Assistant with Grafana and InfluxDB

Prerequisites for installing Docker

Depending on your machine’s operating system, your system must meet some minimum requirements.

Windows 10 system requirements

Windows 11 64-bit or Windows10 64-bit
64-bit processor
4 GB or higher system RAM

Additionally, WSL 2 features and BIOS-level hardware virtualization support must be enabled.

macOS system requirements

macOS version 11 or higher
4 GB or higher system RAM

Additionally, make sure the virtualBox below version 4.3.30 is not installed. It’s not compatible with Docker Desktop.

Linux system requirements

64-bit kernel and CPU
KVM virtualization support
system init system
Gnome, MATE, or KDE desktop environment
4 GB or higher system RAM

Additionally, ensure that configuration ID mapping is enabled in the user namespaces.

How to install Docker

To install Docker, you first need to visit the Docker website.

Now, how to install Docker depends on the OS of your machine. The general steps for installing Docker on Windows, macOS, and Linux are below. You’ll find more information about Docker installation on the official website.

Windows installation

On the Docker website, download the Docker Desktop for Windows installer.
Once downloaded, double-click on the downloaded installer to commence Docker installation.
Follow the prompts to complete the installation.
After successful installation, Docker Desktop will become accessible from your system tray.

macOS installation

On the Docker website, download the Docker Desktop for Mac installer titled Apple Chip.
Once downloaded, double-click on the downloaded installer to commence Docker installation.
Drag the Docker icon to the Application folder to complete the installation.
After successful installation, open Docker from the Application folder.

Linux installation

The process of installing Docker on Linux OSes varies with regard to the distribution or platform. However, for the most part of it, here are the general steps:

On the Docker website, click on the Docker Desktop for Linux installer.
Follow the instructions regarding which platforms are supported (Ubuntu, Debian, and Fedora).
After successful installation, open your application menu and search for Docker Desktop. Select Docker Desktop and start your Docker.

Installing Home Assistant on Docker

There are quite a few ways to install Home Assistant on Docker. We’ll go over a very simple way of installing Home Assistant on Docker, which is by using the CLI on your machine.

If you’re using Windows, just type cmd into the search bar and click on the command prompt from the search result.
If you’re using Linux, open the application launcher, type Terminal into the search bar, and click on the terminal icon to open the terminal application.
If using macOS, type Terminal into the spotlight search bar. Then click on the terminal app icon from the search results to open the terminal.

Now that your terminal is open, all we need to do is to run some Python code to help us install Home Assistant on Docker. Before running the following commands, ensure that your Docker has started running. To do this, open your Docker application.

Step 1: Download the latest stable release of Home Assistant container image from Docker Hub

First, run the code below in your terminal window:

docker pull homeassistant/home-assistant

The code above is a command to pull the latest stable version of Home Assistant container image from Docker Hub. Docker Hub is a popular container registry for Docker images.

After running the code, you’ll get the following output:

Step 2: Install and start the Home Assistant container

To install and start the Home Assistant container, run the command below:

docker run -d –name = homeassistant -v your_home_directory:/config –net=host homeassistant/home-assistant

docker run -d: docker run is a run command to launch a container. The -d means that the container will run in a detached mode. In other words, while you’re busy with the terminal, the container runs in the background.
–name = homeassistant: This specifies the name of the container, in this case, homeassistant, which you can use to refer to the container in the Docker commands.
-v: This sets up a volume for the container. This -v flag is followed by the directory where you would like to store your Home Assistant configuration files as well as the container directory. So, I quickly create a new folder named homeassistant in my root directory. In this case, I’ll replace your_home_directory with C:\homeassistant. At the end of the day, the complete directory after the -v flag will be C:\homeassistant:/config.
–net=host: This sets the container to use the host network rather than creating a separate namespace.
homeassistant/home-assistant: This is the name and tag of the Docker image we already downloaded.

After completing this step, you’ll have the following output:

Step 3: Open your Docker to confirm your Home Assistant container

To confirm that you successfully started the Home Assistant container in your Docker, when you open your Docker, you’ll find a similar output in the figure below:

Step 4: Open your Home Assistant

Right under the Actions tab is a three dots menu, as shown in the figure below. Click on it.

After clicking on it, you get the output result as shown in the figure below. Click on Open with browser to easily open your webpage.

Bravo! Now your Home Assistant is up and running as shown below. Now you can proceed to create an account.

Running Home Assistant on a Docker and standalone

There’s a huge difference between running Home Assistant inside Docker and running it as a standalone service.

Running Home Assistant as a standalone service simply means that you’ve installed it directly on your machine and you don’t need Docker to run it. In contrast, running Home Assistant on Docker simply means that you’re running it in a containerized environment. In other words, it’s isolated from the host system and other containers, and it has its own required resources already in place.

The advantage of running your Home Assistant as a standalone is that it’s simpler to set up and manage, as the software itself and the host system will have no additional layers of abstraction. However, the downside is that it’s less portable and may require more effort to maintain.

The advantage of having to run your Home Assistant on Docker is the fact that the installation and management processes are simplified. Also, all the required resources, dependencies, and configurations are already made available in the Docker image. However, the downside is that it can be more complex to set up. Also, it can be more difficult to troubleshoot since the container environment may be different from the host system.

Common issues

Here are common issues encountered when setting up Home Assistant on Docker.

Issue 1: Docker taking forever to start

After installation, you need to start your Docker engine; however, it’s taking forever to load. To fix this, first close and restart your Docker using administrator privilege. Then run the code below in your terminal window to start Daemon:

cd C:\Program Files\Docker\Docker

./DockerCli.exe -SwitchDaemon

Issue 2: Error message “Error During Connect”

This error can be solved by running the same command in the previous issue.

Issue 3: Not sure if your container is up and running

If, after starting your container in step 2, you’re not sure if your container is up and running, you can run the code below:

docker inspect homeassistant

This code will return all necessary information about your container.

Summary and next steps

Home Assistant is software that allows a user to control and automate home devices, like cameras, thermostats, lights, and sensors. Docker, on the other hand, is a software platform that allows a user to create, deploy, and run software such as Home Assistant in containers. Docker makes it easy to set up the software without any problems arising from the incompatibility of the host system and the software.

To get Home Assistant up and running on Docker, we make use of the host system’s CLI by writing some code. Here are the steps to take to get the Home Assistant running on Docker:

Step 1: Write the code to download the latest stable release of Home Assistant container image from Docker Hub.
Step 2: Write the code to install and start the Home Assistant container.
Step 3: Open your Docker App to confirm your Home Assistant container.
Step 4: Open your Home Assistant.

Once you have your basic Home Assistant installation complete, there is much more you can do with it by integrating other tools like Grafana and InfluxDB. Check out the following resources for some inspiration on what you can do:

About the author

This post was written by Theophilus Onyejiaku. Theophilus has over 5 years of experience as data scientist and a machine learning engineer. He has garnered expertise in the field of Data Science, Machine Learning, Computer Vision, Deep learning, Object Detection, Model Development and Deployment. He has written well over 660+ articles in the aforementioned fields, python programming, data analytics and so much more.

InfluxData Blog - Community

Node-RED Dashboard Tutorial

What is Node-RED?

Prerequisites

Node-RED dashboard installation

Creating a user interface

Dashboard Hierarchy

Creating your first widget

Display a widget on the UI

More examples of widgets

Creating Additional Pages

Building an interactive data visualization

Connecting to real weather data

Dashboard theme and styling

Common issues and fixes

Wrapping up Node-RED dashboard

Node-RED Dashboard FAQs

What is the difference between Node-RED Dashboard 1.0 and Dashboard 2.0?

Can I run the Node-RED dashboard without a Raspberry Pi?

Why are my Node-RED dashboard widgets not showing up?

How do I display live data from an external API in the Node-RED dashboard?

How do I add multiple pages to my Node-RED dashboard?

How do I change the theme or colors of my Node-RED dashboard?

What types of widgets are available in Node-RED Dashboard 2.0?

Exponential Smoothing: A Guide to Getting Started

What is exponential smoothing?

Types of exponential smoothing

1. Simple Exponential Smoothing

2. Holt’s Linear Exponential Smoothing

3. Holt-Winters’ Exponential Smoothing

When to use exponential smoothing

Why is exponential smoothing popular?

How to perform exponential smoothing

Exponential smoothing in Python

The Dataset

Setting Up the Environment

Loading the Data

Visualizing the Data

Performing SES

Making Predictions

Wrapping up

Exponential smoothing FAQs

What is the smoothing parameter α in exponential smoothing and how do I choose it?

What is the difference between simple, double, and triple exponential smoothing?

How do I know which exponential smoothing method to use for my data?

Is exponential smoothing the same as a moving average?

What Python libraries can I use for exponential smoothing?

What are the limitations of exponential smoothing?

How accurate are exponential smoothing forecasts?

Getting Started with InfluxDB and Pandas: A Beginner's Guide

Data science resources

Dependencies

Installations

Import Dependencies

Initialization

Direct Initialization

For Windows Users

Prepare a pandas Dataframe

Write the pandas Dataframe to InfluxDB

Query InfluxDB and return a Pandas DataFrame

Start building with InfluxDB and Pandas

How to Integrate Grafana with Home Assistant in 2026

Definitions: Grafana, Home Assistant, InfluxDB

Home Assistant

Grafana

InfluxDB

Prerequisites and versions

Step 1: Install InfluxDB 3 Core

Step 2: Configure InfluxDB and Generate an API Token

Step 3: Configure the InfluxDB integration in Home Assistant

Verify Data is Flowing to InfluxDB

Step 4: Install Grafana Using Docker

Install Docker

Pull the Grafana Docker Image

Run the Grafana Docker container

Access the Grafana web interface

Create a Grafana account and connect data sources

Configure Grafana

Create a Grafana dashboard

Step 8: View Your Dashboard