Phone Notifications: The Basics of notify
Up to now, the phone has mostly sent data to Home Assistant. Now we'll flip the direction: the home starts sending messages to your phone. You'll send your first test notification and understand what notify actually is, before you build any automation.
In Lessons 1 and 2 you set up the phone as a personal device, not a wall panel. Notifications follow the same rule. Technically a message goes to a specific device, but practically it should be planned for a specific person. We don't send everything to everyone at once, and we don't treat the hallway panel like a household member's phone.
Plan on about forty-five to fifty minutes. By the end you'll send one simple test notification from Home Assistant to your phone. No automation, no ten alerts at once, and no building a system that keeps pinging you from the house.
This lesson's core rule
A good notification is needed, specific, and rare.
We don't start with spam, we start with one sensible test.
What notify is
In Home Assistant, notifications are sent through notify, the action for sending a message. It's one of the ways the system can do something: similar to turning on a light or playing an announcement. Notify says: send this message to a chosen device, say, a phone with the Home Assistant app.
When you installed the Companion App on your phone, Home Assistant usually created its own notify action for it. It's often named something like notify.mobile_app_marek_phone, with the ending coming from the device name from Lesson 3. Every properly registered phone can have its own notification action or target. That way a notification lands where you want it, not on every device in the house.
notify is an action, not a sensor entity
You won't find notifications on the list of phone sensors. You'll find the notify action in Developer Tools or in an automation. Older material may use the word service, but it means the same thing.
Two approaches you may run into
Across different Home Assistant versions and different guides, you may run into two ways of sending notifications. One uses a specific phone action, say, notify.mobile_app_marek_phone. The other uses a general send-notification action and picks the phone as the target. Both lead to the same result: the message reaches the chosen device.
| Approach | What you'll see | What to do at the start |
|---|---|---|
| A specific phone's action | notify.mobile_app_marek_phone | Simplest for a first test, if you see this action on the list. |
| The general notify action | Send a notification message, with the phone entity chosen as the target | Use this if Home Assistant shows your phone as a notify entity. |
Don't panic if the interface looks a bit different
Home Assistant changes over time. If your layout doesn't match this lesson exactly, look for the underlying idea: a notification action, the phone as the target, and title and message fields.
Notify the personal phone, not the panel
The phone in your pocket is a private device. Notifications sent to it reach you, not the whole family at once. The wall panel from Module 14 doesn't replace the phone for alerts: you won't get a push on it when you're away from home.
If there's more than one person at home, each should get notifications on their own phone, not someone else's. An alert like "living room window open" might go to whoever's home, not to every household member without exception. We'll talk more about when and to whom to send in Lesson 8. Right now we're focused on the technical side of sending your first message.
Where to find notify in Home Assistant
The quickest way to run a first test is Developer Tools in Home Assistant. In newer versions of the interface you'll see an Actions tab there. Older material may call it Services. The underlying idea is simple either way: you're picking the action you want Home Assistant to perform, which is sending a notification.
- Go to Settings.
- Open Developer Tools.
- Switch to the Actions tab. Older material may call this Services.
- In the action selector, type notify or mobile_app.
- Choose the notification action for your phone, say, notify.mobile_app_marek_phone.
- Type a test message and run the action.
Action or service
In practice this is the same testing spot: you manually ask Home Assistant to perform a task. Older material more often said "call a service," current interfaces more often say "perform an action."
If you don't see your phone's action, check whether the Companion App is connected to Home Assistant and whether the phone has notifications enabled in its system settings. Without that, the test won't arrive, even if the rest of the configuration looks fine.
Your first test notification
One short message is enough to start. Don't test ten variations right away. Send something simple, say, the title "Test from Home Assistant" and the body "Notifications are working." If it lands on your phone within a few seconds, you've confirmed the channel works.
- Open Developer Tools, Actions tab. In older versions this may be Services.
- Choose notify.mobile_app_ with your phone's name, or the general notify action with your phone as the target.
- Type a short test message in the message field.
- If you see a title field, type a short title.
- Click Perform Action or Call Service, depending on your interface version, and check your phone.
This is a manual test
You're performing the action yourself, once, from Developer Tools. An automation will do the same thing later, but it'll trigger on its own once some condition is met. For now the point is just checking whether a message can reach the phone at all.
A minimal notification data example
Depending on your Home Assistant view, you might fill out form fields, or see the action's data as YAML. You don't need to write an automation yet. It's just worth recognizing that a notification consists of at least a message, and often a title too.
action: notify.mobile_app_marek_phone
data:
title: Test from Home Assistant
message: Notifications are workingChange the phone name
Don't blindly type notify.mobile_app_marek_phone on your own system. Pick the action name Home Assistant shows for your phone. The ending depends on the device name from the mobile app.
Title, body, and what the message means
Even a test notification is worth writing the way you'd want to write a real one. The title says what it's about. The body says what happened or what's worth doing. Short and human, without technical jargon full of entity names and identifiers.
Good: title "Laundry finished," body "You can hang the wash up in the laundry room."
Bad: title "binary_sensor.washer_run_state changed to off," body "entity state update."
A notification should answer the question: why am I looking at my phone right now, and do I need to do anything. If the answer is "I don't know why I got this," it's bad material for a household alert.
A manual test versus an automation
A test from Developer Tools is a one-off run of the notify action. You click, the message flies, that's it. An automation does the same thing, but without your click: some condition is met and Home Assistant sends the notification on its own.
| Approach | When it runs | What it's for at the start |
|---|---|---|
| Manual test | When you run the action yourself in Developer Tools. | Checking whether a notification reaches the phone at all. |
| Automation | When a condition is met, say, a sensor changing state. | Only later, once you know the channel works and have a sensible reason for the alert. |
Channel first, logic second
Don't build an automation with five notifications before you've sent one successful test. Make sure notify works first, then think about when it should fire.
Android, iPhone, and permissions
Android and iPhone don't handle notifications identically, but at the start both need the same thing: the app must have permission to send alerts, and the phone shouldn't have the Companion App muted.
Android: check notification permissions for the Companion App and Do Not Disturb mode. On Android you can also later use notification channels to separate important alerts from less urgent ones.
iPhone: check that notifications are enabled for Home Assistant in iOS settings. Focus modes can mute an alert even when the test technically succeeds.
Leave channels, groups, and advanced settings for later. In this lesson it's enough for one plain notification to reach the phone under normal conditions, with no mute and no system-level block.
What has to work for a notification to arrive
A notification from Home Assistant to a phone passes through several layers. If one of them is blocked, the test might not show up, even though everything looked right when you clicked in Home Assistant.
The phone is registered with Home Assistant: the Companion App has to be connected to your server.
A notify action exists for the phone: the action list shows notify.mobile_app, or the phone as a notification target.
The app has notification permission: Android or iOS isn't blocking alerts for Home Assistant.
The phone has internet or server connectivity: without a connection, a push can arrive late, or not at all.
A focus mode isn't hiding the alert: a focus mode, Do Not Disturb, or a muted channel can keep a notification from popping up on screen.
Changing your phone or the device name
The notify action's name for the mobile app depends on the device registered with Home Assistant. If you replace your phone, remove the app, log in again, or rename the device, the notification's name can change. That's normal, but worth remembering.
Good practice
After changing phones, always run a fresh notify test from Developer Tools. Don't assume the old notify name still works.
How to avoid making spam
The most common notification mistake is too many alerts about things that matter too little. After a week the user stops reacting to them, or turns them off entirely. At that point even an important alert can get ignored.
Notifications have limits too
The Companion App has a limit of 500 pushes per day per device, reset at midnight UTC. In a normal household you shouldn't come anywhere close to it. If you're thinking about hundreds of notifications a day, you're designing a bad system.
Send when it makes sense: a notification should mean something you genuinely want to know right now.
Don't send everything: every single entity state change is a bad reason for an alert if it doesn't need your reaction.
Don't test ten times in a row: one successful test is enough to start. If a test fails, make two or three calm attempts after fixing the settings, rather than spamming the phone every few seconds.
If you're unsure whether something should be a notification, leave it in the entity's history or on a dashboard for now. An alert isn't an event log. It's better to add a notification later than to flood the phone from day one.
A first complete test automation
A manual test is just the action. Create an input_button.test_notification_marek button helper, then deploy the automation below.
alias: "TEST - notification to Marek's phone"
description: "A safe test of the notification channel from a helper."
triggers:
- trigger: state
entity_id: input_button.test_notification_marek
actions:
- action: notify.mobile_app_marek_phone
data:
title: "Test from Home Assistant"
message: "The notification channel is working correctly."
mode: singleWhere to paste the YAML
This is a complete automation. Just action: notify... in Developer Tools is only a test of the action. Swap the notify name for your own. Push limit: 500 per day per device, reset at midnight UTC.
What can go wrong
Sending to the wrong notify action: the notification goes to a different phone, or doesn't go out at all.
The phone has notifications disabled: the test looks successful in Home Assistant, but nothing shows up on screen.
You jump straight to an automation: before checking whether notify even works on your phone.
The body is technical and useless: you see the alert yourself, but don't know what to do about it.
You send too many tests: by the fifth message you stop paying attention to them.
You look for an entity instead of an action: notify won't always be sitting where sensors and phone entities are. Use Developer Tools and Actions for the test.
The phone changed names: after renaming the device or swapping phones, the old notify action might no longer be the right one.
A focus mode hides the alert: the notification may have arrived, but the phone didn't display it on screen.
No internet or connectivity: the phone might receive the notification late, once it regains a connection.
Assignment: send one test notification
To do
☐ Check whether your interface version calls the tab Actions or Services.
☐ Find your phone's notify.mobile_app_ action in Developer Tools.
☐ Check that the Companion App has notifications enabled in your phone's settings.
☐ Send one test notification with a short title and a clear body.
☐ If you're in YAML mode, compare your test against the simple example in this lesson.
☐ Note how much time passed between sending and the alert showing up on your phone.
☐ Write down your phone's full notify action name so you can find it easily later.
☐ Check that your phone doesn't have Do Not Disturb, a focus mode, or a muted app channel active.
☐ Note one thing you don't want notifications about right now, to avoid spam.
☐ If the test doesn't arrive, fix one thing at a time and retest, instead of clicking ten times in a row.
Key takeaways
notify is the action for sending a message, every phone has its own notify.mobile_app_ action.
Actions and Services are the same test location, on newer HA look for the Actions tab in Developer Tools.
Notifications go to the personal phone, not to the wall panel and not to every household member without a plan.
Test manually first, one successful alert from Developer Tools before you build an automation.
The wording should be human, the title and message should say what happened and whether you need to react.
Rare and needed, one good notification beats ten unnecessary ones a day.
What's next
In Lesson 8 we'll move from the technical side of sending a message to designing good notifications: when to send, to whom, with what content, and how to avoid building a system that bombards the phone at every minor change in the house.
For now you have a working channel between the home and the phone. That's a small technical step, but a big practical one: Home Assistant can talk to you. Now it needs to learn to talk only when it makes sense.
