Services

Company

Book a free meeting

REVIEWED ON

31 REVIEWS

E: support@multiverseapp.com

Linkedin Github Facebook Youtube

@2026

Multiverse Software India Pvt. Ltd.

Build Flutter App With Home Assistant

April 1, 2025

Build Flutter App With Home Assistant

Learn how to build a Flutter Home Assistant client from scratch using the home_assistant Dart package. This step‑by‑step guide shows you how to connect to your Home Assistant instance, fetch entities, and control devices (lights, switches, climate, and more) with a simple Flutter UI.

Iot

Flutter

Home Assistant

Introduction

Home Assistant is an amazing open‑source platform to automate your home, but most people interact with it only through the official app or web UI. Flutter opens the door to building your own custom mobile experiences on top of Home Assistant’s API.

The home_assistant Dart package gives you a simple, high‑level API to talk to Home Assistant from any Dart or Flutter app. With it, you can connect to your instance, read configuration, fetch entities and their states, and call services to control lights, switches, climate devices, and more.

In this tutorial, you’ll build a small Flutter Home Assistant dashboard that:

Connects to a Home Assistant instance using a base URL and token
Verifies the API is working
Fetches entities and inspects their state
Calls services to turn lights and switches on and off

By the end, you’ll have a working Flutter Home Assistant client using the home_assistant package as your SDK.

Prerequisites

Before you start, you should have:

A running Home Assistant instance that you can access over HTTP(S)
A long‑lived access token from your Home Assistant profile
Flutter installed and set up
Basic familiarity with Dart and Flutter widgets

The package you’ll use is published on pub.dev as home_assistant.

Step 1: Create a new Flutter project

Create a new Flutter project for the dashboard:

Dart

1flutter create flutter_home_assistant_dashboard
2cd flutter_home_assistant_dashboard

Run the template app to make sure everything works:

Dart

1flutter run

Step 2: Add the home_assistant package

Open pubspec.yaml and add the dependency:

Dart

1dependencies:
2  flutter:
3    sdk: flutter
4  home_assistant: ^<latest-version>

Replace <latest-version> with the current version from pub.dev.

Then fetch dependencies:

Dart

1flutter pub get

Launch Your Own App

Want to build an app, but not sure where to start? We develop mobile apps for any platform, matching your vision and business. Book a free consult and let’s chat about what’s possible for your brand.

Get Your Free App Consultation

Now you can import the package in your Dart files:

Dart

1import 'package:home_assistant/home_assistant.dart';

The HomeAssistant class is your main entry point for talking to the API.

Step 3: Create a Home Assistant client

In lib/, create a file home_assistant_client.dart to centralize your API access.

Dart

1import 'package:home_assistant/home_assistant.dart';
2class HomeAssistantClient {
3  final HomeAssistant _homeAssistant;
4  HomeAssistantClient({
5    required String baseUrl,
6    required String token,
7  }) : _homeAssistant = HomeAssistant(
8          baseUrl: baseUrl,
9          bearerToken: token,
10        );
11  Future<bool> verifyApi() {
12    return _homeAssistant.verifyApiIsWorking();
13  }
14  Future<Configuration> fetchConfig() {
15    return _homeAssistant.fetchConfig();
16  }
17  Future<List<Entity>> fetchEntities() {
18    return _homeAssistant.fetchStates();
19  }
20  Future<Entity> fetchEntity(String entityId) {
21    return _homeAssistant.fetchState(entityId);
22  }
23  Future<List<Service>> fetchServices() {
24    return _homeAssistant.fetchServices();
25  }
26  Future<void> toggleSwitch(String entityId, bool turnOn) {
27    return _homeAssistant.executeService(
28      entityId,
29      turnOn ? 'turn_on' : 'turn_off',
30      additionalActions: const {},
31    );
32  }
33  Future<void> turnOnLight(String entityId,
34      {int? brightness, int? colorTemp}) {
35    final data = <String, dynamic>{};
36    if (brightness != null) data['brightness'] = brightness;
37    if (colorTemp != null) data['color_temp'] = colorTemp;
38    return _homeAssistant.executeService(
39      entityId,
40      'turn_on',
41      additionalActions: data,
42    );
43  }
44}

This is a thin wrapper around the HomeAssistant object, exposing the main methods from your library: verifying the API, fetching config and states, reading a single entity, listing services, and executing services for switches and lights.

Step 4: Build a simple connection screen

You want a simple first screen where the user enters the base URL and token for their Home Assistant instance.

Create lib/connection_screen.dart:

Dart

1import 'package:flutter/material.dart';
2import 'home_assistant_client.dart';
3import 'dashboard_screen.dart';
4class ConnectionScreen extends StatefulWidget {
5  const ConnectionScreen({super.key});
6  @override
7  State<ConnectionScreen> createState() => _ConnectionScreenState();
8}
9class _ConnectionScreenState extends State<ConnectionScreen> {
10  final _urlController = TextEditingController();
11  final _tokenController = TextEditingController();
12  bool _loading = false;
13  String? _error;
14  Future<void> _connect() async {
15    setState(() {
16      _loading = true;
17      _error = null;
18    });
19    final client = HomeAssistantClient(
20      baseUrl: _urlController.text.trim(),
21      token: _tokenController.text.trim(),
22    );
23    try {
24      final isWorking = await client.verifyApi();
25      if (!isWorking) {
26        setState(() {
27          _error = 'Home Assistant API is not responding.';
28        });
29        return;
30      }
31      if (!mounted) return;
32      Navigator.of(context).push(
33        MaterialPageRoute(
34          builder: (_) => DashboardScreen(client: client),
35        ),
36      );
37    } catch (e) {
38      setState(() {
39        _error = 'Failed to connect: $e';
40      });
41    } finally {
42      setState(() {
43        _loading = false;
44      });
45    }
46  }
47  @override
48  Widget build(BuildContext context) {
49    return Scaffold(
50      appBar: AppBar(
51        title: const Text('Connect to Home Assistant'),
52      ),
53      body: Padding(
54        padding: const EdgeInsets.all(16),
55        child: Column(
56          children: [
57            TextField(
58              controller: _urlController,
59              decoration: const InputDecoration(
60                labelText: 'Base URL',
61                hintText: 'https://your-home-assistant-url',
62              ),
63            ),
64            const SizedBox(height: 12),
65            TextField(
66              controller: _tokenController,
67              decoration: const InputDecoration(
68                labelText: 'Long-lived access token',
69              ),
70              obscureText: true,
71            ),
72            const SizedBox(height: 24),
73            if (_error != null)
74              Text(
75                _error!,
76                style: const TextStyle(color: Colors.red),
77              ),
78            const SizedBox(height: 12),
79            ElevatedButton(
80              onPressed: loading ? null : connect,
81              child: _loading
82                  ? const CircularProgressIndicator()
83                  : const Text('Connect'),
84            ),
85          ],
86        ),
87      ),
88    );
89  }
90}

Home Assistant Sample App Connection Screen

This screen uses your library’s verifyApiIsWorking method to check connectivity before navigating to the dashboard.

Step 5: Show a dashboard of entities

Now create a dashboard that lists entities from Home Assistant using fetchStates, which your library exposes as returning a list of Entity models.

Add lib/dashboard_screen.dart:

Dart

1import 'package:flutter/material.dart';
2import 'home_assistant_client.dart';
3import 'package:home_assistant/home_assistant.dart';
4class DashboardScreen extends StatefulWidget {
5  final HomeAssistantClient client;
6  const DashboardScreen({super.key, required this.client});
7  @override
8  State<DashboardScreen> createState() => _DashboardScreenState();
9}
10class _DashboardScreenState extends State<DashboardScreen> {
11  late Future<List<Entity>> _futureEntities;
12  @override
13  void initState() {
14    super.initState();
15    _futureEntities = widget.client.fetchEntities();
16  }
17  Future<void> _refresh() async {
18    setState(() {
19      _futureEntities = widget.client.fetchEntities();
20    });
21  }
22  bool _isLight(Entity e) => e.entityId.startsWith('light.');
23  bool _isSwitch(Entity e) => e.entityId.startsWith('switch.');
24  @override
25  Widget build(BuildContext context) {
26    return Scaffold(
27      appBar: AppBar(
28        title: const Text('Home Assistant Dashboard'),
29      ),
30      body: RefreshIndicator(
31        onRefresh: _refresh,
32        child: FutureBuilder<List<Entity>>(
33          future: _futureEntities,
34          builder: (context, snapshot) {
35            if (snapshot.connectionState == ConnectionState.waiting) {
36              return const Center(child: CircularProgressIndicator());
37            }
38            if (snapshot.hasError) {
39              return Center(
40                child: Text('Error: ${snapshot.error}'),
41              );
42            }
43            final entities = snapshot.data ?? [];
44            if (entities.isEmpty) {
45              return const Center(child: Text('No entities found.'));
46            }
47            return ListView.builder(
48              itemCount: entities.length,
49              itemBuilder: (context, index) {
50                final entity = entities[index];
51                // Filter only lights and switches for this simple UI
52                if (!_isLight(entity) && !_isSwitch(entity)) {
53                  return const SizedBox.shrink();
54                }
55                final isOn = entity.state == 'on';
56                final friendlyName =
57                    entity.attributes['friendly_name'] ?? entity.entityId;
58                return ListTile(
59                  title: Text('$friendlyName'),
60                  subtitle: Text('${entity.entityId} (${entity.state})'),
61                  trailing: Switch(
62                    value: isOn,
63                    onChanged: (value) async {
64                      try {
65                        if (_isSwitch(entity)) {
66                          await widget.client
67                              .toggleSwitch(entity.entityId, value);
68                        } else if (_isLight(entity)) {
69                          if (value) {
70                            await widget.client
71                                .turnOnLight(entity.entityId, brightness: 255);
72                          } else {
73                            await widget.client.toggleSwitch(
74                                entity.entityId, false);
75                          }
76                        }
77                        await _refresh();
78                      } catch (e) {
79                        if (!mounted) return;
80                        ScaffoldMessenger.of(context).showSnackBar(
81                          SnackBar(content: Text('Failed: $e')),
82                        );
83                      }
84                    },
85                  ),
86                );
87              },
88            );
89          },
90        ),
91      ),
92    );
93  }
94}

Home Assistant Sample App Entities List

This screen demonstrates the core value of your package in a Flutter UI: using fetchStates to list entities and executeService to control them.

Step 6: Wire everything in main.dart

Replace the default main.dart with:

Dart

1import 'package:flutter/material.dart';
2import 'connection_screen.dart';
3void main() {
4  runApp(const MyApp());
5}
6class MyApp extends StatelessWidget {
7  const MyApp({super.key});
8  @override
9  Widget build(BuildContext context) {
10    return MaterialApp(
11      title: 'Flutter Home Assistant',
12      theme: ThemeData(
13        colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
14        useMaterial3: true,
15      ),
16      home: const ConnectionScreen(),
17    );
18  }
19}

Now you have a working Flutter Home Assistant app:

Enter your Home Assistant base URL and token
Verify the API using verifyApiIsWorking
Fetch entities with fetchStates
Toggle switches and lights via executeService behind toggleSwitch and turnOnLight helpers

These calls mirror the example usage of your library published on pub.dev.

Step 7: Explore configuration and services

Your library also exposes methods for reading Home Assistant configuration and listing service definitions.

For example, you can show basic configuration info (like location, version, and more) on the dashboard:

Dart

1Future<void> _showConfigDialog() async {
2  final config = await widget.client.fetchConfig();
3  if (!mounted) return;
4  showDialog(
5    context: context,
6    builder: (_) {
7      return AlertDialog(
8        title: const Text('Home Assistant Config'),
9        content: SingleChildScrollView(
10          child: Text(config.toJson().toString()),
11        ),
12        actions: [
13          TextButton(
14            onPressed: () => Navigator.of(context).pop(),
15            child: const Text('Close'),
16          ),
17        ],
18      );
19    },
20  );
21}

You can also inspect available services:

Dart

1Future<void> _logServices() async {
2  final services = await widget.client.fetchServices();
3  for (final service in services) {
4    debugPrint('${service.domain}');
5  }
6}

This highlights how your Dart models (Configuration, Entity, Service) map Home Assistant’s API into strongly typed objects.

Step 8: Calling more advanced services (e.g., climate)

You are not limited to lights and switches. The same executeService API can control climate entities with extra parameters.

For example, to set a thermostat temperature:

Dart

1Future<void> setTemperature(String entityId, double temperature) {
2  return widget.client._homeAssistant.executeService(
3    entityId,
4    'set_temperature',
5    additionalActions: {
6      'temperature': temperature,
7      'hvac_mode': 'heat',
8    },
9  );
10}

In your production code, you’d expose a method on HomeAssistantClient instead of touching the underlying HomeAssistant instance directly, but the core idea is the same: call executeService with the entity id, the service name, and a map of additional data.

You can then bind this to sliders or dropdowns in Flutter to build a richer climate control UI.

Step 9: Putting it all together

At this point, your Flutter Home Assistant app showcases the full flow:

Initialize HomeAssistant with base URL and bearer token
Verify connectivity with verifyApiIsWorking
Fetch configuration using fetchConfig
Fetch all entity states using fetchStates
Read details of a single entity via fetchState
Inspect available services using fetchServices
Control entities (switches, lights, climate) using executeService

All of these APIs are provided by the home_assistant package; your Flutter code focuses purely on UI and simple state management.

You can see the package’s example code on pub.dev for a console‑style usage of the same APIs.

For your app, you’ve wrapped those calls in a basic, discoverable Flutter UI that can be extended with theming, persistent config, and more advanced controls.

Authored by