Home Assistant

Eine native HACS-Integration, die Statusänderungen von Home-Assistant-Entitäten als PushWard-Live-Aktivitäten auf dein iPhone bringt.

Requirements

• Home Assistant 2025.7.0 or newer
• PushWard iOS app installed on your iPhone
• A PushWard integration key (your default key works out of the box)

Installation

Via HACS (Recommended)

PushWard is in the default HACS store, so there is no custom repository to add.

1. Open HACS in Home Assistant
2. Search for "PushWard"
3. Open it and click Download
4. Restart Home Assistant

Manual

Copy custom_components/pushward/ from the repository into your Home Assistant's custom_components/ directory and restart.

Setup

Go to Settings > Devices & Services > Add Integration > PushWard.

Verwende deinen Standard-Integrationsschlüssel aus der PushWard-App unter Einstellungen → Integrationsschlüssel oder erstelle einen bereichsbeschränkten Schlüssel für diese Integration.

Adding Entities

After setup, click "Add tracked entity" on the integration card. Each entity becomes a Live Activity.

Each value (remaining time, progress, subtitle, gauge value, current step, fired-at) can read from a separate entity or attribute, so an appliance with separate state and time-remaining sensors needs no template helper.

The board and log templates compose several entities into one activity. A board shows 1–4 tiles, each reading from a separate entity; a log shows a newest-first list of up to 20 lines, with optional extra columns (an attribute or another entity's value) and a per-line severity level.

Domain Defaults

Start/end states and icons are pre-filled based on the entity's domain. The default icons are Material Design (mdi:) names, which PushWard accepts alongside SF Symbols:

Activity Lifecycle

Start

The integration listens for state changes on the entities you configure. When an entity enters a start state (e.g., a washer turns on), it creates the activity on PushWard (if it doesn't exist) and a Live Activity appears on your Lock Screen via push-to-start.

Updates

While active, any state or attribute change — on the tracked entity or any configured companion entity — triggers a throttled update. Rapid changes are coalesced — only the latest state is sent when the cooldown expires. The integration is entirely event-driven, so the update interval is a rate-limiter, not a polling period.

End

When the entity reaches an end state, a two-phase dismissal runs:

1. A "Complete" update is sent (green accent, checkmark icon). The progress bar keeps its last value rather than jumping to 100% -- only the steps and gauge templates fill the bar to its maximum.
2. After 5 seconds, the activity is ended and dismissed from the Lock Screen

If the entity starts again during the 5-second window, the end is cancelled.

HA Restart

On Home Assistant restart, any tracked entity already in a start state automatically resumes its Live Activity.

Notifications, Widgets & Email

Beyond mirroring entities to Live Activities, the integration exposes services for the rest of the PushWard surface. Each needs the matching permission on your integration key — your default key has all of them:

• iOS widgets — add a tracked widget sub-entry (event- or poll-triggered, 10–3600 s) to push Home Screen widgets in the value, progress, gauge, status, and stat_list templates, or call pushward.widget_refresh to force a refresh and pushward.delete_widget to remove one. Needs widgets at write.
• Push notifications — the pushward.send_notification service sends a regular (non-Live-Activity) push with title, body, level (including critical), actions, and rich media. It can also send the notification later or on a repeating schedule, and its buttons can record an answer for the automation to act on. Needs notifications at send, or schedule for scheduled ones.
• Transactional email — the pushward.send_email service delivers email to a verified recipient of your account. Needs emails at send.

For driving an activity straight from an automation (rather than tracking an entity), the create, update, end, and delete services are all available. Update actions are template-specific — pushward.update_activity_generic, …_steps, …_gauge, and so on — so each action's form only shows the fields that template uses.

Scheduled and repeating notifications

Add send_at to pushward.send_notification and PushWard holds the notification and sends it at that time, at most 365 days ahead. A time picked in the action editor has no UTC offset, so it is read in Home Assistant's time zone. The send happens on PushWard's side: Home Assistant does not have to be running when it goes out. For reminders from the due dates on a to-do list, with no script to write, use a tracked to-do list.

To repeat it, add a recurrence object:

• Set until or count, not both. With neither, the series runs until you cancel it.
• With a recurrence, send_at is optional and marks where the series starts. Without it, the first send is the next time the cron expression matches, which must be within 365 days.
• A repeating notification keeps one id for the whole series and takes one of the 25 slots an account has for pending scheduled notifications.
• Scheduling is free. Each send counts toward your notification quota when it goes out.

Set response_variable on the action to get the id back. A scheduled or repeating send returns scheduled_notification_id, send_at (the next send) and recurrence; one sent right away returns notification_id and answerable. The response only lives for that run, so the example below keeps the id in an input_text helper for the script that stops the reminder.

script:
  start_school_run_reminder:
    alias: Start the school run reminder
    sequence:
      - action: pushward.send_notification
        data:
          title: School run in 15 minutes
          body: Shoes, bags, lunch boxes.
          source: home
          recurrence:
            cron: "0 8 * * 1-5"
        response_variable: reminder
      - action: input_text.set_value
        target:
          entity_id: input_text.school_run_reminder_id
        data:
          value: "{{ reminder.scheduled_notification_id }}"

  stop_school_run_reminder:
    alias: Stop the school run reminder
    sequence:
      - action: pushward.cancel_scheduled_notification
        data:
          scheduled_notification_id: "{{ states('input_text.school_run_reminder_id') | int }}"

pushward.cancel_scheduled_notification cancels the schedule, and the PushWard app shows it as canceled for 24 hours. For a repeating one that stops the whole series, even while one of its sends is going out: that send arrives only if it had already gone out, and nothing is sent after it. An id that no longer exists is ignored, so running the stop script twice does no harm.

pushward.list_scheduled_notifications returns scheduled_notifications, a list. status picks which ones: scheduled (the default: still pending, including one being sent right now), sent and failed (both kept for 7 days), canceled (kept for 24 hours) or all. Repeating items also carry recurrence, occurrence (sends so far) and last_sent_at. It only sees the notifications scheduled with this integration's key.

Statuses, failure reasons and more cron examples are on the scheduled notifications page.

Notification answers

Give a notification action no url and PushWard records the tap itself: which button was chosen, and when. Add text_input: true to such an action and the person can type a reply, which is recorded with it (text_input_placeholder and text_input_button_title label the field). An action with foreground: true and no url only opens the app and is never recorded. When at least one action will be recorded, the send_notification response has answerable: true.

pushward.get_notification_answer reads the answer for a notification_id. It waits up to timeout seconds (default 300, at most 86400) and returns as soon as the answer lands, so the automation pauses on that step and the person has that long to tap. timeout: 0 reads once without waiting.

automation:
  - alias: Ask before closing the garage door
    triggers:
      - trigger: state
        entity_id: cover.garage_door
        to: open
        for: "00:30:00"
    actions:
      - action: pushward.send_notification
        data:
          title: Garage door open
          body: It has been open for 30 minutes. Close it?
          level: time-sensitive
          actions:
            - id: close
              title: Close
              icon: door.garage.closed
            - id: ignore
              title: Ignore
              destructive: true
        response_variable: sent
      - action: pushward.get_notification_answer
        data:
          notification_id: "{{ sent.notification_id }}"
          timeout: 3600
        response_variable: answer
      - choose:
          - conditions:
              - condition: template
                value_template: "{{ answer.action_id == 'close' }}"
            sequence:
              - action: cover.close_cover
                target:
                  entity_id: cover.garage_door

Ignore, and no answer within the hour, both leave the door as it is. The response carries these fields:

• The first answer wins. Once one device has answered, later taps on any device change nothing.
• Answers are kept for 30 days. An automation that should not sit and wait can store the notification_id and read the answer later with timeout: 0.
• A Home Assistant restart stops a waiting automation like any other. The answer stays on PushWard, so a later read with timeout: 0 still finds it.

How recording works, and its limits, is covered on the notification answers page.

- action: pushward.send_notification
  data:
    title: "Water leak"
    body: "Sensor under the kitchen sink"
    level: time-sensitive
    acknowledge:
      repeat_seconds: 120
      action_title: "On it"
    tags: [leak]
  response_variable: sent

- alias: Leak cleared, stop nagging
  triggers:
    - trigger: state
      entity_id: binary_sensor.kitchen_leak
      to: "off"
  actions:
    - action: pushward.cancel_notifications
      data:
        tag: leak

To-do reminders

A tracked to-do list turns the due dates on a Home Assistant to-do list into PushWard reminders. Add one under Settings > Devices & Services > PushWard > Add tracked to-do list and pick any todo entity, such as a Local To-do list. Every open item with a due date gets a scheduled notification: the item's title is the push title, and its description is the body (the list name when it has no description).

Say the list has a 30 minute lead and you add "Dentist", due tomorrow at 15:00. PushWard schedules a push titled Dentist for 14:30 tomorrow, with a Done button. Tap Done and the item is ticked off in Home Assistant; move the appointment to 16:00 and the reminder moves to 15:30.

• Adding or editing an item schedules or replaces its reminder right away. Completing or deleting it cancels the reminder.
• PushWard sends the push itself, so it arrives even if Home Assistant is offline at that time.
• An item due more than 365 days out is scheduled once it comes within range. An item whose reminder time has already passed gets its reminder within a minute, unless it is more than 90 minutes past due; then it gets none.
• If you stop a reminder in the PushWard app, the item stays open and gets no new reminder until you change its due date or time. Renaming an item whose reminder already went out does not send it again either.
• After a reminder goes out, the item stays open until you tick it off. With the Done button, Home Assistant watches for the tap for 24 hours.
• Every pending reminder takes one of the 25 slots the account has for scheduled notifications, shared with anything else that schedules them. Leave room below 25 if your automations schedule notifications too.
• Which reminder belongs to which item is kept in Home Assistant's storage, not in the item, so notes synced to other apps (Apple Reminders through the Home Assistant app's Reminders Sync, for example) stay clean.
• Removing the list, or the whole integration, cancels its pending reminders.

Account Sensors

The integration also creates five sensors that track your PushWard usage against your plan, refreshed about every 15 minutes:

• sensor.pushward_notifications_used
• sensor.pushward_live_activity_updates_used
• sensor.pushward_widget_updates_used
• sensor.pushward_emails_used
• sensor.pushward_subscription_tier — free or premium

Example: Washing Machine

Track a washing machine using a sensor entity with a progress attribute: