Tag Archives: Apprise

Setup Apprise Notifications on Home Assistant


Apprise allows you to notify just about all of the most popular notification services out there. In fact, there were more then 65 supported services at the time of writing this blog. By integrating it into your Home Assistant environment:

  1. You can securely define all of your notification service end points in one easy to manage location. You can even store these endpoints in configuration elsewhere on your network by leveraging the API allowing you to centralize your configuration and/or decouple it.
  2. You don’t have to try to find the specialized Home Assistant integration for a service you use because most likely Apprise already supports it!
  3. All of the notifications are all sent asynchronously; hence everything gets notified at the same time and not one after another.
  4. You can leverage tagging to easily filter the flow of what messages go where (all explained in this blog).
Home Assistant Apprise Overview
Home Assistant Apprise Overview

Apprise In A Nutshell

Let’s start with the basics… Apprise is built around ingesting specifically formatted URLs which provides it everything it needs in order to send a notification. The URLs are structured as {service}://{credentials}. For example, below are a few of the the most popular services based on traffic to it’s wiki page:

  • TelegramFor a Telegram Notification the Apprise URL looks like:
       You can read more about the structure here
  • DiscordFor a Discord Notification the Apprise URL looks like:
       You can read more about the structure here
  • EMailFor an Email the Apprise URL looks like:
       You can read more about the structure here

Feel free to have a look at all of the supported Apprise notification services and their accompanying URL documentation here. You can optionally also have a look at this blog entry too if you wish to to test your URL outside of Home Assistant.

Home Assistant Integration

URL Based Setup

The following simple Home Assistant package will get you started in your configuration.yaml file:

# inside your configuration.yaml file:
  name: apprise
  platform: apprise
  # A Hotmail Example:
  url: "mailto://user:pass@hotmail.com"

Next you can create a simple automation that fires off your notification:

# An example automation:
- alias: "[Interactive] - Sunset Notice"
    platform: sun
    event: sunset

    service: notify.apprise
      title: "Good evening"
      message: "This sun is setting."

There are no limits to the number of Apprise URLs you define. The more you identify, the more that get automatically notified when you reference the notify.apprise service. You can identify more then one notification endpoint by simply updating your entry in your configuration.yaml file to look like so:

# inside your configuration.yaml file:
  name: apprise
  platform: apprise
    # A Hotmail Example:
    - "mailto://user:pass@hotmail.com"
    # A Slack server:
    - "slack://MY/TOKEN/INFORMATION"
    # A KODI Server
    - "kodi://my.kodi.server.local"

Apprise File Based Configuration Setup

If you leverage the Apprise configuration as an access point of your Home Assistant setup, you have the power to do a lot more customization with your notifications and how they are triggered. Let’s start with what your entry would look like in your configuration.yaml file:

# inside your configuration.yaml file:
  name: apprise
  platform: apprise
  # use the 'config' keyword
  # configuration file:
  config: /config/apprise.yaml

Now here is what your Apprise configuration file might look like:

# /config/apprise.yaml
# Our Apprise Configuration File leveraging Tagging
  # Set up a email notification
  - "mailtos://user:mysecretpassword@gmail.com":
    - tag: me, family
      to: myuser@gmail.com
    - tag: family
      to: myspouse@gmail.com, mykid@gmail.com

  # Set up a PushBullet notification
  - "pbul://o.jh33GTY7fpMCbl5gsp8Wk6IJOu43AqCC":
    - tag: me, pushbullet
  - "pbul://o.yy44GTY7fpMCbl5gsp6Aw6IJOu43AqDD":
    - tag: spouse, pushbullet

  # Setup our KODI instances and assign them both to the
  # tv tag
  - "kodi://kitchen.pi.lead2gold.local":
    - tag: tv

  - "kodi://livingroom.pi.lead2gold.local":
    - tag: tv

  # Our DevOps team at work
  - "slack://SPECIAL/TOKEN":
    - tag: devops

The above configuration file leverages tagging by assigning 1 or more tags with all of the identified notification end points. This plays a big roll into how you define your automations now.

Now automation might now look like this:

# An example automation to notify everything identified:
- alias: "[Interactive] - Sunset Notice"
    platform: sun
    event: sunset

    service: notify.apprise
      # 'all' is a special keyword that will cause
      # everything to get notified regardless of the
      # tag already associated with it. 
      target: all
      title: "Good evening"
      message: "This sun is setting."

But by leveraging tagging, we can customize our notifications to just address ‘some’ of the endpoints we identified:

# An example automation to notify everything identified:
- alias: "[Interactive] - Download Completed"
    platform: event
    event_type: nzbget_download_complete

    service: notify.apprise
      # Just notify the services that have the tv tag
      # associated with them. This will not notify
      # anything that does not have the identified tag
      # associated with it:
      target: tv
      title: "Download completed!"
      message: "{{trigger.event.data.name}}"

Where things get really cool, is Apprise is smart enough to work our OR‘s and AND‘s.

For cases where you only want to notify entries that have tagA AND tagB associated with them, you would do the following:

# Leverage the 'AND' keyword
# ...
  service: notify.apprise
    # Just notify the services that have the me AND family
    # tag associated with them.
    # This will not notify anything that does not otherwise
    # meet this criteria:
    target: me, family
    title: "Explicitly matching Tags using AND"
    message: "I will only notify myuser@gmail.com defined in the example above."

The more tags you identify that are separated, the more AND’ing (and more restrictive) the check becomes.

For cases where you only want to notify entries that have tagA OR tagB associated with them, you would do the following:

# Leverage the 'OR' keyword
# ...
  service: notify.apprise
    # Just notify the services that have the tv, pushbullet,
    # or me tag associated with them.
      - me
      - pushbullet
      - tv
    title: "Explicitly matching Tags using OR"
    message: >-
        This triggers on everything except the `devops` Slack post and the
        emails to myspouse@gmail.com and mykid@gmail.com that were defined
        above under the 'family' tag which wasn't identified in the targets

You may have guessed it now, but if you want to combine OR and AND together, you just identify them as such:

# Leverage the 'OR' and the 'AND' keyword
# ...
  service: notify.apprise
    # Just notify the services that have the me AND family tag associated with
    # it.  Also include any services that have the devops tag as well.
      - me, family
      - devops
    title: "Email myself only and notify Devops on Slack"
    message: >-
        Testing out the AND and OR together

Now you might be asking: Why would I have my DevOps team be part of my Home Assistant configuration? Well the answer to this question makes more sense in the next section.

Apprise Web Based Configuration Setup

Apprise follows a universal configuration and has already been integrated in many other platforms. If you’re using Apprise elsewhere on your network (or with a team), you may have chosen to host a central configuration. This way you can define all of your Apprise URLs in one location (and not have them spread out across your other servers). If you set up tagging appropriately, you’ll be able to notify only the specific endpoints required; nothing more, nothing less. For those taking advantage of the API (a cloud based centralized configuration end point), you just need to point your Home Assistant Configuration to it as http://apprise.server.local:8000/get/{KEY} where {KEY} is what where you set your configuration up as. So your configuration.yaml file might look like this:

# inside your configuration.yaml file:
  name: apprise
  platform: apprise
  # Retrieve our Apprise configuration from a remote location.
  # with respect to the below, we're using the default `apprise`
  # key/token:
  config: http://apprise.server.local:8000/get/apprise


This blog took me a very (,very) long time to put together and test! If you like what you see and wish to copy and paste this HOWTO, please reference back to this blog post at the very least. It’s really all I ask. Alternatively, I certainly won’t turn down a coffee if you wish to buy me one! πŸ™‚


Integrate Apprise into Nagios for More Notification Support


Apprise is an open source tool that allows you to send a notification through a wide range of messaging services out there (such as Discord, Slack, Telegram, Microsoft Teams, etc). Well when you combine this with Nagios, you open it up to a much larger scope then simply emailing on an alert.

With Apprise you can configure Nagios to text your mobile phone using Amazon’s Web Service, or notify your devops team on Slack and/or Microsoft Teams. You can even trigger an IFTTT event. But it doesn’t just stop there, Apprise already supports over 35+ notification services today (and is always expanding) which means Nagios could leverage all of this too. This blog will explain how you can set up your instance of Nagios to notify more end points then just email.

The Installation

I’m going to presume you have a copy of Nagios already installed. If you don’t you can check out my blog here on how to set up your own copy with CentOS 7. Those who are not using CentOS are certainly not out of luck though, there are lots of blogs out there to get you started.

This blog will assume you have root privileges or have sudoers privileges.

Apprise can be easily added to your system through pip:

# Install Apprise onto the system currently also hosting Nagios
sudo pip install apprise

Configure Nagios

The Nagios configuration files can vary in their location depending on what Linux distribution you’re using. I’m going to just refer to some standard paths used by the stuff I host here (for CentOS/RedHat).

Step 1: Nagios Import Directory

If you’re using the Nuxref RPMs, then you can skip this step and move to the next as you’ll already be configured for this. Those using another distribution will want to update their nagios.cfg to point to a directory we can use to drop in and remove configuration from. The file is presumably going to be located as: /etc/nagios/nagios.cfg):

# Place this anywhere in /etc/nagios/nagios.cfg
# preferably put it near the bottom of the file.

# Definitions for global configuration directory

Now make sure this directory exists because this is where we’ll place our new apprise configuration:

# Ensure our global include directory exists that we
# just defined in our nagios.cfg file:
mkdir -p /etc/nagios/conf.d

# Place a dummy file in here so that Nagios doesn't
# throw any errors (as it isn't a fan of include directories
# without configuration files in it).
touch /etc/nagios/conf.d/dummy.cfg

Step 2: Apprise/Nagios Integration

Now we need to let Nagios know about Apprise. We’ll do this by creating the following files called /etc/nagios/conf.d/apprise.cfg

# Apprise to Nagios Configuration File
# Place this file as /etc/nagios/conf.d/apprise.cfg
# 'notify-host-by-apprise' command definition
define command{
   command_name   notify-host-by-apprise
   command_line   /usr/bin/printf "%b" "- *Notification Type*: $NOTIFICATIONTYPE$\n- *Host*: $HOSTNAME$\n- *State*: \n- *Address*: $HOSTADDRESS$\n- *Info*: $HOSTOUTPUT$\n\n- *Date/Time*: $LONGDATETIME$\n" | /usr/bin/apprise -c /etc/nagios/apprise.yml -n "$HOSTSTATE$" -g "$NOTIFICATIONTYPE$" -t "** $NOTIFICATIONTYPE$ Host Alert: $HOSTNAME$ is $HOSTSTATE$ **"
# 'notify-service-by-apprise' command definition
define command{
   command_name   notify-service-by-apprise
   command_line   /usr/bin/printf "%b" "*Notification Type*: $NOTIFICATIONTYPE$\n- *Service*: $SERVICEDESC$\n- *Host*: $HOSTALIAS$\n- *Address*: $HOSTADDRESS$\n- *State*: $SERVICESTATE$\n- *Date/Time*: $LONGDATETIME$\n\n*Additional Info*:\n$SERVICEOUTPUT$\n" | /usr/bin/apprise -c /etc/nagios/apprise.yml -n "$HOSTSTATE$" -g "$NOTIFICATIONTYPE$" -t "** $NOTIFICATIONTYPE$ Service Alert: $HOSTALIAS$/$SERVICEDESC$ is $SERVICESTATE$ **"

# Register our contact template that we can reference
define contact{
  ; The name of this contact template
  name                             apprise-contact

  ; service notifications can be sent anytime
  service_notification_period      24x7

  ; host notifications can be sent anytime
  host_notification_period         24x7

  ; send notifications for all service states, flapping events,
  ; and scheduled downtime events
  service_notification_options     w,u,c,r,f,s

  ; send notifications for all host states, flapping events,
  ; and scheduled downtime events
  host_notification_options        d,u,r,f,s

  ; send service notifications via email
  service_notification_commands    notify-service-by-apprise

  ; send host notifications via email
  host_notification_commands       notify-host-by-apprise

  ; Don't register this as it is just a template for future
  ; references by contacts who wish to use the apprise plugin
  register                         0

Now for every contact we set up going forward, we can point it to use Apprise. By default Nagios usually provides us a contact.cfg file that contains the generic user nagiosadmin. For those using my packaging, you can find this file at /etc/nagios/objects/contacts.cfg; you’ll want to change it to looks like this:

define contact{
  ; Short name of (Nagios) user
  contact_name    nagiosadmin

  ; This next line used to read generic-contact; but we want to switch it
  ; over to our new Apprise based one:
  use             apprise-contact

  ; Full name of user
  alias           Nagios Admin

  ; not important if using apprise-contact (defined above)
  email           nagios@localhost

Before you advance to the next step, you’ll want to run a test flight check on your configuration and make sure it validates okay.

# Perform a flight check on our new configuration (as root)
sudo nagios -v /etc/nagios/nagios.cfg

If you get any errors, you should revisit the first part of this blog and try to iron them out before continuing. If everything is error free, then the next step is to reload our instance of Nagios (if it’s running) so it can re-read this configuration. This can be done with the command:

# You will need to be root to do this; send a SIGHUP
# to all instances of nagios running in memory:
sudo killall -HUP nagios

Step 3: Apprise Configuration

Now we need to prepare our Apprise configuration (/etc/nagios/apprise.yml) and fill it with the notification services we want listen for and who we want to pass it to.

We can associate with Nagios notifications types passed to us through tags. Nagios will pass these along one of the following $NOTIFICATIONTYPE$ when an event occurs; these are:

  • PROBLEM: There was an issue with one of the checks.
  • RECOVERY: The issue previously set has been cleared.
  • ACKNOWLEDGEMENT: An outstanding issue has been acknowledged.
  • FLAPPINGSTART: Flapping is a state where a service has a PROBLEM associated with it and then moments later has a RECOVERY. This is the state called FLAPPING. When this process occurs too many times in a row, this alert gets set.
  • FLAPPINGSTOP: The service that was previously FLAPPING is no longer doing so.
  • FLAPPINGDISABLED: Someone just disabled FLAPPING for this service/host.
  • DOWNTIMESTART: The scheduled downtime for this service/host has begun.
  • DOWNTIMEEND: The scheduled downtime is over.
  • DOWNTIMECANCELLED: Someone just cancelled the scheduled downtime for this service/host.

Knowing the above notification types that we’ll receive, here is what an Apprise configuration file located at /etc/nagios/apprise.yml might look like:

# This file should be placed in /etc/nagios/apprise.yml

#       VISIT https://github.com/caronc/apprise TO SEE WHAT IS

# Identify all of the global notification types we want to flag on.

# Now we want to define our Apprise URLS; you'll want to visit
# https://github.com/caronc/apprise to see all of the supported
# services and how to build their URLs.

  # Maybe we want to notify a custom service we're hosting to
  # monitor and track Nagios status; Check out the following 
  # for more details https://github.com/caronc/apprise/wiki/Notify_json

  - json://localhost

  # Maybe we want to notify a Slack channel; more details on this
  # are here: https://github.com/caronc/apprise/wiki/Notify_slack
  - slack://T1JJ3T3L2/A1BRTD4JD/TIiajkdnlazkcOXrIdevi7F/#nuxref

  # the Apprise YAML configuration is quite powerful, the
  # following prepares the email URL and sends an email to each
  # user identified below:
  - email://user:password@gmail.com
      - to: george@example.com
      - to: admin@example.com

  # More details on the emails can be found here:
  # https://github.com/caronc/apprise/wiki/Notify_email

  # We can also individually disperse the tags in the same config
  # file.  The below tags will override the globals defined above.
  # A use case for this would be that maybe we just want to
  # send certain notification types to say... the DevOps team:
  - email://user:password@gmail.com
      - to: devops@example.com

Once you’re file is all ready, be sure this file is readable by Nagios (to keep it away from prying eyes), but otherwise you’re all set and ready to go!

# Here is what one might do to protect this apprise configuration
chmod 640 /etc/nagios/apprise.yml
chown nagios.root /etc/nagios/apprise.yml


To be sure everything works, you may want to just test that you got all of your configuration right You can test this using manually as follows:

# Test our configuration with apprise using the PROBLEM tag
# -vvv for some verbose debugging in-case we need it.
apprise -c /etc/nagios/apprise.yml \
    -vvv \
    -t "A Test Title" \
    -b "a Test Body"

Here is a screenshot of a test error displayed on gitter.im that was sent by Nagios using Apprise:
Gitter Example