DEV Community: Yubal Torres

Setting up a persistent notifications tray for Home Assistant

Yubal Torres — Mon, 29 Jun 2026 06:57:15 +0000

Disclaimer: This tutorial will use Pulsetray, a tool I've developed myself.

Introduction

If you use Home Assistant, you probably send notifications to your phone using the Companion App. It's great for letting you know when a door opens or a camera sees motion, but it has one problem I hated: There's no notifications tray.

While the Companion App notifications are highly customizable, they don't get stored anywhere. Once you dismiss an alert from your phone, it's gone forever.

I wanted a persistent searchable history of notifications, so I built a tool to fix it. This tutorial will show you how to setup an Android app to centralize your Home Assistant notifications, along with categories, rich media and a permanent history. You can even extend this to other platforms you'd like to monitor, like GitHub, UniFi Protect, and more.

Let's dive in!

1. Install and configure Pulsetray

First, we need to set up the app to receive alerts.

Download the Pulsetray app from the Play Store and complete the sign up process.
Navigate to Settings > API keys > Add API key
Enter a name and click on Add key.
Copy the generated Token immediately. You will use this token to authorize POST requests from Home Assistant, and this is the only time it'll be visible.

With the app being all set, let's move onto Home Assistant.

2. Setup a rest_command in Home Assistant

Next, we need to prepare Home Assistant to allow it to talk to Pulsetray. We will do this by creating a rest_command in your configuration.yaml file, which allows Home Assistant to send HTTP requests to external APIs.

Open your configuration.yaml file (you can use the File Editor add-on).
Append the YAML block shown below to the end of the file.
Replace YOUR_TOKEN with the API token you copied in the previous step.

rest_command:
  pulsetray:
    url: "https://api.pulsetray.com/v1/notifications"
    method: post
    content_type: "application/json"
    headers:
      Authorization: "Bearer YOUR_TOKEN"
    payload: "{{ json_body | to_json }}"

The payload: "{{ json_body | to_json }}" line allows us to define the specific contents of the notification later when we create our automation.

Save the file and restart your Home Assistant instance to apply the changes.

3. Create the automation

Once Home Assistant reboots, we can set up the actual trigger. For this example, I'll configure an alert that fires when my Samsung fridge door has been left open for more than 30 seconds.

In Home Assistant, go to Settings > Automations & scenes > + Create automation > Create new automation.

The trigger (When)

Click on + Add trigger
Select Device and choose your specific device (e.g. Fridge)
Select the trigger action (e.g. Fridge door opened) and set the duration to 30 seconds.

The action (Then do)

Click on +Add action
Search for and select RESTful Command: pulsetray
Click the three dots in the corner of the action and select Edit in YAML
Paste the following YAML code to define your notification payload:

action: rest_command.pulsetray
metadata: {}
data:
  json_body:
    title: Fridge door is open
    body: Fridge door has been open for more than 30 seconds
    androidConfig:
      priority: high

Done! You can now save the automation. To test the action, click the three dots at the top of the automation and select Run actions. You should receive a notification to your phone instantly.

Bonus! Organizing with Categories

Centralizing notifications is great, but a flat list can get messy really quickly. To separate and filter our alerts, we'll use sources and categories.

In the Pulsetray app, go to Settings > Sources and categories
Click + Add source. Set the code to home-assistant, and the name to Home Assistant. Save it.
In the source you've just created, click on + Add category. Set the code to fridge and the name to Fridge. Save it.

Now, go back to your Home Assistant automation and update your YAML action to include the new codes we've created:

action: rest_command.pulsetray
metadata: {}
data:
  json_body:
    title: Fridge door is open
    body: Fridge door has been open for more than 30 seconds
    source: home-assistant
    category: fridge
    androidConfig:
      priority: high

Save the automation, and you're good to go! You'll now be able to filter and separate your notifications at a glance.

Wrapping up

I built this tool to solve a problem I had, and I hope more people find it useful. You can integrate it with any service that supports POST requests or webhooks, like Vercel, GitHub or UniFi Protect.

To find more usages and customization, you can take a look at the docs.

If you have any questions or suggestions please let me know!

🚀 Why I built my own push notification tool for CI/CD and Home Assistant

Yubal Torres — Mon, 22 Jun 2026 16:17:08 +0000

Nowadays, we all need push notifications. Whether it's for home automation, CI/CD deployments, application monitoring, UniFi Protect, or more.

But, you'll eventually realize that most of those services don't feature push notifications, or those that do, don't offer a permanent history or tray at all (such as Home Assistant).

So, I created Pulsetray

The problem

The idea was simple: I needed an Android app that could receive push notifications with an API request. I wanted to send alerts from my Home Assistant instance, my deployments, database monitoring, and Unifi Protect into one place.

Most importantly, I wanted a persistent history, a way to organize my notifications by origin or category, and the ability to attach rich media like video footage or screenshots.

Research

Naturally, my immediate approach was to do a quick Google search and download the first app that popped up. To my surprise, I found two things:

Chat apps: Most people use chat apps for this purpose, such as Telegram or WhatsApp. It works, but it's clunky, you're mixing notifications from all places and you have limited filtering and storage.
Outdated alternatives: There are some services out there, but they either look really outdated, lack features, or have a local-only approach. Uninstall the app, upgrade your phone or sign in from a different device and your notifications are gone for good.

Building the solution

At this point, I knew I had a problem that I needed to solve myself, and I wanted to build it as a SaaS for others facing the same friction.
Instead of writing a massive technical deep-dive (I'll save this for a future post), here's a high-level overview of the products I created over the last 8 months:

The app: I built the Android app using Kotlin and Kotlin Compose. (Compose is amazing!). This is available in the Play Store.
The web dashboard: Soon after releasing the initial MVP, I figured that forcing users to download the app to use the service was an important activation problem. I would either have traffic with no interaction, or users downloading the app without using it. I recently deployed a Web dashboard that lets users sign up, configure profiles/devices, send test notifications, setup webhooks, and more. This was deployed to Vercel, and is available on Pulsetray.
The backend: This is a monolith (handles both the internal API for the app and dashboard, and the public API for users to trigger notifications) created with Node.js, Express, and TypeScript. For notifications I'm using FCM, of course. This was deployed to Render (and PlanetScale for the MySQL database).

The features

What started as a simple POST request endpoint and an Android app has grown into a much more mature platform. I recently deployed a Web Dashboard and Incoming Webhooks.

Here's what Pulsetray can do right now:

Simple API: Trigger notifications with a standard POST request.
Profiles and devices: You can add more people to your account, and devices. You can onboard devices using a unique token. Notifications can be sent to the entire account, or specific profiles and devices.
In-app notifications tray: Have persistent and searchable history of notifications.
Rich media support: You can attach an image, video or GIF when sending a notification.
Highly customizable: Each notification can have title, body, rich media, and more. They can also be assigned a source (e.g. Home Assistant, GitHub, Unifi, etc.) and a category (e.g. Deployment, Camera, Log, etc.) for easy filtering.
Webhooks: You can trigger notifications with incoming webhooks by just pasting a URL into services like GitHub, Vercel or Sentry. You can configure the title, body, image, targets, and even extract specific information from the JSON body using dot notation to format your notification.
Free plan: I designed the Free plan to be as generous as possible, offering enough notification limits for most people, no bank details required. Paid plans are available for users needing higher limits to help sustain the service.

The code

Code is worth more than a thousand words, so here's how simple it is to send a notification:

curl -X POST https://api.pulsetray.com/v1/notifications \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
  "title": "Script finished running",
  "body": "Production DB backup finished running"
}'

That's it!

Feedback!

My goal is to keep improving the project, so your feedback will be more than welcome! Right now the very next step I have in sight is creating the iOS counterpart, but please, give me your thoughts, suggestions, or questions you may have.