Menu

Mattering Automations Pushover integration

Connect Pushover to Mattering Automations: send push notifications and watch glances, run emergency-priority pages that repeat until a human acknowledges them, manage delivery groups, and read the monthly message allowance, all from one application token.

The Mattering Automations Pushover integration puts push notifications on your automation canvas. Send a message to a phone, watch or desktop, send it at emergency priority so it repeats until somebody acknowledges it, read the receipt that proves they did, cancel the retries when the condition clears, manage the delivery groups an alert is addressed to, and read the account's remaining monthly message allowance. Nineteen nodes in total, seven that read and twelve that act, which is the entire surface an application token can reach.

The credential is a single application token that you create on pushover.net. Pushover has no Authorization header and no OAuth flow: the token travels as an ordinary request parameter, so setup is one paste into Add Connector and a Test Connection click. There is no plan to upgrade and no approval to wait for.

Two things are worth reading before you build anything. First, the token is not the recipient. An application token and a user key are both 30-character strings, they identify completely different things, and Pushover reports the mix-up as an ordinary validation error rather than as an authorization failure, so it reads like a typo. Second, emergency priority carries obligations: retry and expire are both required at priority 2, and a misconfigured emergency message rings a real person repeatedly through their quiet hours. Both are explained in full below, and this guide ends with the complete node reference.

Before you start

  • A Pushover account with an application registered on it. Pushover describes registering an application as a free process, and the application's page is where the 30-character API token comes from. No paid plan is required to call the API.
  • The recipient's user key, or a delivery group key. This is a separate value from the application token and comes from the recipient's own Pushover dashboard, or from Pushover: List Delivery Groups once you have a group. You can save one on the connection as a default and override it per node.
  • The Pushover client app installed on the device you intend to notify. This is the recipient's side rather than yours: Pushover's apps are free for 30 days and then a one-time purchase per platform, and Pushover for Teams is a per-user monthly subscription. The API being free does not make the phone app free, and a notification sent to somebody with no active device goes nowhere.
  • Headroom in the monthly message allowance. Pushover documents 10,000 messages per month for free per account, shared across every application on that account, and 25,000 for Teams. A send to a delivery group counts as one message for each member, so a rota of twenty costs twenty.
  • A deliberate decision about emergency priority before you use it. Priority 2 bypasses the recipient's quiet hours and repeats with sound until acknowledged. Agree with the people who carry the phone that this is what you are building, and test it against your own device first.
  • A Mattering workspace with access to the Automations app.

Create a Pushover application token

Pushover authenticates with one value: an application token, which identifies the thing doing the sending. There is nothing to negotiate, no scopes to choose and no review process. The only real decision is whether to also save a default recipient on the connection, and the only real risk is copying the wrong 30-character string.

Sign in at pushover.net and open Your Applications, then click Create an Application/API Token. Give it a name that will make sense on a device, because Pushover uses the application's name as the notification title when a message does not set one.
Copy the API Token/Key shown on the application's page. It is 30 characters.
Do not copy your user key here. Your user key is on your Pushover dashboard and identifies you as a recipient; the application token is on the application page and identifies your app as a sender. They are both 30 characters and look identical. Getting them the wrong way round does not produce an authorization error: Pushover answers with an ordinary validation error naming the field it could not resolve, which is why this mix-up is usually diagnosed as a typo.
Decide whether you want a default recipient on the connection. If this connection will usually notify one person or one rota, have that user key or group key ready. If it will notify many different people, leave it blank and set the recipient on each node.
The default recipient is scoped on purpose. It fills in only on the three nodes whose recipient means notify this person: Pushover: Send Message, Pushover: Send Glance and Pushover: Validate User Or Group. It is never applied to the group membership nodes, to Pushover: Assign License or to Pushover: Migrate User To Subscription, where the user key means somebody else entirely. Those nodes require the key to be typed.

Connect Pushover to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Pushover from the list, then click Create new credential.
Paste the application token into the Application token field. If you decided to use one, paste the user key or group key into the optional Default recipient field. Save the credential.
The token is stored encrypted and never appears in workflow logs. Both the token and the default recipient are registered for redaction, so neither shows up in a run's output even if a node echoes its request.
Click Test Connection. Mattering calls Pushover's sounds endpoint with nothing but the token: it has no side effect, notifies nobody and returns no secret material, so it is the cheapest proof that the token is real and belongs to a live account.
A successful test proves the token, not the recipient. Pushover has no endpoint that lists the users an application may notify, so nothing at connect time can validate a user key you have not sent to. Run Pushover: Validate User Or Group against the key you plan to notify before you rely on it.
All 19 Pushover nodes appear in your canvas palette.

Verify it works

Drop Pushover: Validate User Or Group onto a canvas, put the user key or group key you intend to notify in the recipient field, and run a test step. This is the verification that matters, because it exercises both halves of the setup: the application token authenticates the call, and the recipient key is confirmed to be real, attached to an active account, and carrying at least one device that can receive a notification. It sends nothing and notifies nobody despite being a POST. The response also lists the recipient's device names, which is what the device pickers on the other nodes read.

Run Pushover: Get Message Limits next. It takes no configuration and returns the account's monthly allowance, how much of it is left and when the counter resets. It is a second confirmation that the token works, and it tells you whether you have room to build before you start sending. Remember that this allowance is shared by every application on the Pushover account, not just this one.

Only then send something real. Put Pushover: Send Message on the canvas, aim it at your own device, leave priority at 0, and run it. Watch for the notification and confirm the title reads the way you want, since a message with no title shows the application's name. Do not test emergency priority casually: if you want to prove the priority 2 path, use your own device with a short expire such as 60 seconds so the alert stops on its own, and read the receipt with Pushover: Get Emergency Receipt afterwards.

Node reference

19 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 7

Pushover: Get Delivery Group

pushover_get_group

Read one delivery group's name and its full membership: each member's user key, the device their membership is restricted to, the free-text memo they were added with, and whether they are currently disabled. Use it to check who an alert will actually reach before sending, and as the source for the member pickers on the remove, disable and enable nodes. Team-owned groups also return each member's name and email.

Pushover: Get Emergency Receipt

pushover_get_receipt

Check whether an emergency-priority notification has been acknowledged yet, who acknowledged it and on which device, when it was last retried, whether it has expired, and whether the callback URL has fired. EMERGENCY ONLY: a receipt exists only for a message sent at priority 2, so this node has nothing to read for any other message. Poll no faster than once every 5 seconds, and prefer a callback URL on the send node if the workflow can receive one. Receipt data is kept for up to a week after delivery.

Pushover: Get License Credits

pushover_get_license_credits

Read how many pre-paid Pushover license credits this application has left to hand out, without spending one. Relevant only if you distribute Pushover client licences to your own users; most connectors never touch it. Check this before Pushover: Assign License, because credits are not refundable and an assignment cannot be undone.

Pushover: Get Message Limits

pushover_get_limits

Read this account's monthly message allowance, how much of it is left, and when the counter resets. Free accounts get 10,000 messages a month and Teams get 25,000, shared across every application on the account, and one message to a delivery group counts once PER MEMBER. Once the allowance is gone every application on the account is refused with HTTP 429 until the 1st of the month, so a workflow that sends in volume should check this and degrade rather than discover the wall mid-run.

Pushover: List Delivery Groups

pushover_list_groups

List every delivery group on the account, with each group's key and name. A delivery group lets one send reach a whole on-call rota without the workflow holding anybody's personal user key. This is the source of every group picker in this connector, and a group key can be used directly as the recipient of Pushover: Send Message.

Pushover: List Sounds

pushover_list_sounds

List every notification sound this application may specify, which is the built-in set plus any custom sounds uploaded to the account that owns the token. Takes nothing but the application token, so it is also the cheapest way to prove a connection works. Pushover returns the sounds as a hash keyed by sound name; this node adds a matching data.sound_list array alongside the untouched data.sounds hash so the sound pickers on the other nodes have something to read.

Pushover: Validate User Or Group

pushover_validate_user

Check that a user key or group key is real, belongs to an active account, and has at least one device able to receive a notification. Sends nothing and notifies nobody despite being a POST. Run it before storing a key a person typed in, and run it in a workflow before an emergency send so a mistyped key fails loudly instead of silently notifying no one. Also returns the recipient's device names, which is what every device picker in this connector reads, and the platforms their account is licensed for.

Action nodes 12

Pushover: Add User To Delivery Group

pushover_add_group_user

Add a person to a delivery group, so every future send to that group reaches them too. Reversible with Pushover: Remove User From Delivery Group. Remember the cost model: each member of a group counts as one message against the monthly allowance every time the group is notified.

Pushover: Assign License

pushover_assign_license

Spend one pre-paid license credit to license the Pushover client for one user on one platform. DESTRUCTIVE and it costs real money: Pushover states credits are not refundable and that once assigned a license cannot be revoked or reassigned. One call licenses ONE platform, so a user who wants both Android and iOS needs two calls and two credits. The vendor explicitly recommends never automatically retrying this call - raise the error and get a human involved. Check the balance first with Pushover: Get License Credits.

Pushover: Cancel Emergency Retries

pushover_cancel_receipt

Stop one emergency-priority notification from being retried, before it expires on its own. EMERGENCY ONLY: there is no receipt and nothing to cancel for a message sent at any other priority. DESTRUCTIVE: it silences an alert that a person may still need to see, and it cannot be restarted - sending again means a new message and a new receipt. Use it when the condition that raised the alert has cleared.

Pushover: Cancel Emergency Retries By Tag

pushover_cancel_receipts_by_tag

Stop EVERY still-active emergency notification this application sent carrying a given tag, in one call. EMERGENCY ONLY, and only for messages that were sent with a tags value in the first place. This is the recovery half of a fan-out alert: tag every 'server down' page with the datacenter, then cancel the whole datacenter when the outage clears, without having stored a single receipt id. DESTRUCTIVE and broad - a tag matching more messages than you expected silences all of them, and there is no preview call.

Pushover: Create Delivery Group

pushover_create_group

Create an empty delivery group and return its key, so a workflow can address a whole rota with one recipient value instead of holding everyone's personal user key. Add members with Pushover: Add User To Delivery Group. Note that Pushover exposes NO delete-group endpoint: an unwanted group has to be removed by hand in the groups editor on pushover.net, so do not put this node in a loop.

Pushover: Disable User In Delivery Group

pushover_disable_group_user

Temporarily stop sending group notifications to one member, keeping their membership row, memo and device restriction intact. This is the node for an on-call handover or a holiday: reversible at any time with Pushover: Enable User In Delivery Group. Be aware that a disabled member will not be paged, so a rota that disables everyone pages nobody.

Pushover: Enable User In Delivery Group

pushover_enable_group_user

Resume sending group notifications to a member who was disabled, putting them back on the rota. The exact inverse of Pushover: Disable User In Delivery Group, and harmless to run against a member who was never disabled.

Pushover: Migrate User To Subscription

pushover_migrate_subscription

Convert a user key your application already holds into a subscribed user key under one of the application's subscriptions, so the user can later unsubscribe themselves instead of asking you to stop. Returns the new key, and the vendor's instruction is to discard the old one. DESTRUCTIVE: Pushover exposes no reverse call, so a migration run against the wrong subscription cannot be undone through the API. Only relevant to applications that collected raw user keys before adopting subscriptions.

Pushover: Remove User From Delivery Group

pushover_remove_group_user

Remove a person from a delivery group. DESTRUCTIVE: they stop receiving every alert sent to that group from this moment on, silently and with no notification to them, and their memo and device restriction are gone - re-adding needs their user key again. If the goal is a temporary pause, use Pushover: Disable User In Delivery Group instead, which is reversible and keeps the row.

Pushover: Rename Delivery Group

pushover_rename_group

Change a delivery group's display name, in the API and in the groups editor on pushover.net. The group KEY does not change, so nothing that sends to this group breaks. Reversible by renaming it back.

Pushover: Send Glance

pushover_send_glance

Update the small data widget on a recipient's watch face, without notifying them. A glance makes no sound and raises no alert; it just replaces whatever the widget was showing, which is why this is a reversible write and Pushover: Send Message is not. Only the fields you supply are overwritten, so several workflows can feed different lines of the same widget. Apple Watch is currently the only supported widget and the recipient must already have one registered. Pushover does not throttle this, but watchOS does: send no more than about one every 20 minutes, and expect up to 10 minutes before it appears.

Pushover: Send Message

pushover_send_message

Send a push notification to a person's phone, watch or desktop. DESTRUCTIVE: it reaches a real human being and there is no recall: the API exposes no call that withdraws, edits or deletes a notification once it has been accepted. Treat it like sending mail, not like writing a row. Priority 2 (emergency) is worse still: it REPEATS with sound and vibration every retry seconds, bypassing quiet hours, until a human acknowledges it or expire seconds elapse, and the only way to stop it early is Pushover: Cancel Emergency Retries. Free accounts share 10,000 messages a month across every application, and a send to a delivery group costs one message per member.

Using the integration

The two keys, and the failure that looks like a typo

Pushover uses two 30-character strings that look alike and mean opposite things. The application token identifies who is sending, comes from the application page on pushover.net, is required by all nineteen endpoints, and is the value the connection holds. A user key or group key identifies who is being notified, comes from the recipient's own dashboard or from Pushover: List Delivery Groups, and is only needed on the sending and validation nodes. Swapping them is the most common first failure with this integration, and it does not present the way people expect: Pushover treats an invalid application token as invalid input and answers with HTTP 400 carrying a status of 0 and an errors array, not with 401 or 403. So a run that failed because the two values were transposed reads like a bad parameter rather than like a bad credential. The design here follows from that. The token, which is authentication, lives on the connection where it can be rotated once. The recipient, which is routing, lives on the node, because one Pushover application legitimately notifies many people and that is what the entire groups surface exists for. The connection may carry a default recipient as a convenience for the common case of one person notifying their own phone, and the node always wins over it.

Emergency priority, and what it obliges you to set

Priority 2 is what makes Pushover an on-call tool rather than a notification tool. Pushover repeats the notification with sound and vibration every retry seconds, bypassing the recipient's quiet hours, until a human acknowledges it or expire seconds have passed. Both parameters are required at priority 2, and the integration checks that client-side before sending, because Pushover's own error for the omission is an ordinary validation error indistinguishable from a typo. Retry has a documented minimum of 30 seconds and expire a documented maximum of 10800 seconds, which is three hours, but the total number of retries is capped at 50 regardless of expire. That cap surprises people: retry set to 30 with expire set to 10800 actually stops after 25 minutes, not three hours. Three further behaviours are worth knowing. A priority 2 send returns a receipt, and that is the only way to learn about acknowledgement, since Pushover ships no endpoint that lists an application's receipts. When the recipient is a delivery group, the first member to acknowledge cancels retries for everyone else. And the time-to-live parameter is ignored at priority 2, so an emergency message does not self-delete. Everything else the connector does is ordinary; this is the part to design carefully, because a misconfiguration does not send one unwanted notification, it sends up to fifty of them with sound.

Receipts, callbacks, and stopping an alert

Pushover: Get Emergency Receipt reads whether a priority 2 message was acknowledged, who acknowledged it, on which device, when it was last delivered, whether it has expired and whether the callback fired. Pushover keeps receipt data for up to a week after delivery and asks that it be polled no faster than once every 5 seconds. If a workflow can receive an inbound request, the callback field on the send node is better than polling: Pushover posts to that URL as soon as somebody acknowledges, carrying the receipt, the acknowledged flag and time, and the user and device that acknowledged it, and it retries every minute until it gets a 2xx. Point it at a Mattering webhook trigger URL and acknowledgement becomes a push rather than a poll. This is Pushover calling a URL you own rather than a managed webhook subscription, and the integration does not describe it as webhook support, because Pushover has no outbound webhook management API and this connector has no trigger nodes. To stop an alert early there are two nodes, both classed destructive because silencing a page somebody is relying on has consequences of its own. Pushover: Cancel Emergency Retries takes the receipt id from the send. Pushover: Cancel Emergency Retries By Tag takes a tag that was set on the send and stops every still-active message carrying it, which is the pattern to prefer: a workflow that tagged its pages by service or location can silence a whole incident in one call without having stored a single receipt id. Cancelling by tag is broad and has no preview call, so choose tags that mean exactly what you want to cancel.

Delivery groups, and the arithmetic they change

A delivery group lets one send reach a rota without the workflow holding anybody's personal user key. Pushover: Create Delivery Group returns a group key, Pushover: Add User To Delivery Group populates it, and any sending node can then take the group key as its recipient. Give every member a memo when you add them: it is Pushover's own free-text name or email field, the only human-readable label a group row carries, and it is what the member pickers on the remove, disable and enable nodes display. A member added without one shows as a raw 30-character key. For handovers and holidays use Pushover: Disable User In Delivery Group and Pushover: Enable User In Delivery Group, which keep the membership row, its memo and its device restriction intact. Pushover: Remove User From Delivery Group is classed destructive because the person stops being paged immediately and silently, with no notification to them, and their memo and device restriction are gone. Two structural notes. Pushover ships no endpoint to delete a group, so an unwanted group has to be removed by hand in the groups editor on pushover.net, which is a reason not to create groups in a loop. And group membership changes what a send costs: Pushover counts one message for each user in the group, so notifying a twenty-person rota draws twenty messages from the monthly allowance rather than one.

The monthly allowance, and building inside it

Pushover documents 10,000 messages per month for free per account, with all applications belonging to that account sharing the quota, and 25,000 per month for Teams. One message is one successful messages call to one user, regardless of how many devices that user has. Once the allowance is exhausted, Pushover answers HTTP 429 and rejects further message creation from every application on the account, not just the one that used it up, until limits reset at 00:00:00 Central Time on the 1st of each month. Every messages call returns the current state in X-Limit-App-Limit, X-Limit-App-Remaining and X-Limit-App-Reset response headers, and Pushover: Get Message Limits returns the same three values in a body so a workflow can read and branch on them. That is the node that makes volume manageable: a batch job should check remaining before it starts and degrade to a digest, a queue or a quieter channel rather than discovering the wall halfway through. Pushover also asks integrators not to create more than two concurrent connections to its API, so a fan-out that sends per row is better paced than parallelised. If the free allowance is genuinely not enough, Pushover sells additional monthly capacity.

Glances, which notify nobody

Pushover: Send Glance updates the small data widget on a recipient's watch face without producing any notification at all: no sound, no vibration, no alert. It simply replaces what the widget was showing, which is why it is classed as a reversible write while Pushover: Send Message is not. Supply at least one of the five data fields, since Pushover requires it: a title, a main line of text, a subtext line, a plain count that may be negative, or a percent from 0 to 100. Only the fields you send are overwritten, so several workflows can feed different lines of the same widget without clearing each other, and sending an empty string is how you clear one. Apple Watch is currently the only supported widget and the recipient must already have a device registered. The schedule is the constraint worth designing around: Pushover does not throttle glances itself, but watchOS enforces a limit of 50 updates per day, Pushover recommends at least 20 minutes between calls, and it can take up to 10 minutes for a value to appear on the face. A glance is for a number somebody wants to look at, not for a change they need to know about now.

Reading responses, and the one field the integration reshapes

Every Pushover endpoint answers with a JSON object carrying status, which is 1 on success and anything else on failure, and request, a per-call identifier worth quoting if you contact Pushover support. The integration puts the raw body in the node's data, so downstream steps read data.status, data.request, data.receipt, data.groups, data.users, data.devices and data.credits directly. Because Pushover reports failure with an HTTP 4xx as well as a status of 0, the node's own success flag and Pushover's verdict agree, and there is no case where one is right and the other is wrong. Failures add an errors value, and there is one inconsistency to know about: it is an array of strings on every endpoint except licensing, where it is an object keyed by parameter, so a path expression written for the array form will not resolve on a licensing failure. One response is reshaped and only one. Pushover returns the sound catalogue as a hash keyed by sound name, and path expressions on this platform fan out over lists rather than enumerating dictionary keys, so the sound pickers would have nothing to read. Pushover: List Sounds therefore adds a derived sound_list array beside the untouched sounds hash. Nothing is removed or renamed, and the vendor's hash is still exactly where it was.

On the automation canvas and from AI assistants

Pushover nodes chain with every other node in Mattering, which is the point: the system that detected the problem and the notification that reaches a person live in the same workflow. A monitoring webhook can page a rota at priority 2, wait, read the receipt and escalate. A scheduled query can send a digest at normal priority in the morning and a glance to a watch face during the day. A form submission, a failed job or a threshold in a database can all end in one send. Every node also speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. The useful division is that the assistant reads and judges while Pushover carries the interruption, and the reason to run it here rather than in a local assistant config is that these nodes fire on a schedule with nobody present and hold the application token once in a shared workspace. Six nodes are flagged destructive and are worth keeping behind a condition or an approval step when an agent holds them: sending a message, cancelling retries either way, removing a group member, assigning a license and migrating a subscription.

Licensing and subscriptions, the two nodes that spend something

These two exist for applications that distribute the Pushover client to their own users, and most workflows never touch them. Pushover: Get License Credits reads how many pre-paid credits the application has left, without spending one. Pushover: Assign License spends a credit to license the client for one user on one platform, and it is classed destructive for a financial reason rather than a data one: Pushover states that credits are not refundable and that once assigned a license cannot be revoked or reassigned to another user. Each call licenses one platform, so a user who wants both Android and iOS costs two credits. Leave the platform field blank unless you have a reason not to, which is Pushover's own recommendation, so that the credit lands on the first platform the user actually registers rather than being stranded on one they never use. Pushover also recommends never automatically retrying a failed licensing call, so raise the error and get a human involved. Pushover: Migrate User To Subscription converts a user key the application already holds into a subscribed key, which lets the user unsubscribe themselves later instead of asking you to stop; it is destructive because Pushover exposes no reverse call. Neither node accepts the connection's default recipient, deliberately: both act on somebody else's account and both are unrecoverable.

Troubleshooting

A node fails with HTTP 400 and an errors message saying the application token is invalid
This is what a bad credential looks like on Pushover, and the status code is the confusing part. Pushover does not answer a bad application token with 401 or 403: it treats an invalid token as invalid input and returns HTTP 400 with a body carrying a status of 0 and an errors array. Check the token first for the classic transposition, where the user key was pasted into the application token field. The token comes from the application's own page on pushover.net and the user key comes from your dashboard, and both are 30 characters. If the token is right, confirm the application still exists and has not been deleted on the Pushover side, then re-save the credential in Connectors to rule out a truncated paste.
A send fails saying there is no recipient for this node
The node had no recipient and the connection had no default to fall back on. Fill in the recipient field on the node with the user key or group key to notify, or save a default recipient on the Pushover credential in Connectors. Two things to check while you are there. The recipient is not the application token, and pasting the token here produces a validation error naming the user parameter rather than an authorization error. And the default is scoped deliberately: it fills in only on Pushover: Send Message, Pushover: Send Glance and Pushover: Validate User Or Group, so a group membership node, Pushover: Assign License or Pushover: Migrate User To Subscription that reports a missing user key needs the key typed in, because those act on somebody else's account and a silent fallback there would be dangerous.
An emergency message is rejected, or the node reports that retry and expire are missing
Pushover requires both retry and expire whenever priority is 2, and the integration checks it before sending so the message names the emergency rule instead of reading like a generic validation failure. Set retry to the seconds between repeats, minimum 30, and expire to the seconds after which retrying stops, maximum 10800. Then sanity-check the pair against the retry cap: Pushover stops after 50 retries regardless of expire, so retry 30 with expire 10800 actually ends after 25 minutes. If the message sends but nothing repeats, confirm the priority field is really 2 rather than 1, since high priority bypasses quiet hours but does not repeat and returns no receipt.
Requests start failing with HTTP 429 partway through a run
The Pushover account is out of monthly message allowance. Pushover documents 10,000 messages per month free per account, shared by every application belonging to that account, and 25,000 for Teams, and once the allowance is gone it rejects further message creation from every application on the account until limits reset at 00:00:00 Central Time on the 1st of the month. Two causes are worth checking before you assume the volume was legitimate. Group sends count one message per member, so a rota of twenty costs twenty per send, which multiplies faster than people expect in a retry loop. And the allowance is shared, so another application on the same Pushover account may have consumed it. Put Pushover: Get Message Limits at the start of any workflow that sends in volume and branch on the remaining count, and buy additional capacity from Pushover if the free allowance genuinely is not enough.
The device picker says to choose a user key first, or shows the wrong person's devices
The device list is per recipient, so the picker is deliberately gated on the recipient field: Pushover returns device names from a validation call against one user key, and there is no account-wide device list. A node that inherits the connection's default recipient leaves its recipient field blank, so the picker has nothing to scope itself by and gates instead of populating. That is intended rather than a fault. Type the recipient key into the node to populate the list, or leave the device field blank, which reaches all of the recipient's active devices and is usually what you want. Note also that the device restriction is ignored when the recipient is a delivery group or a comma-separated list of users, because each member's own device restriction wins.
The sound picker is empty, or a sound name is rejected
Run Pushover: List Sounds on its own first: every sound picker in this integration reads from it, so if the lister returns nothing the picker cannot populate either. If the lister works and the picker still looks empty, check that the node is reading the derived list rather than the raw hash. Pushover returns sounds as a hash keyed by sound name, and path expressions on this platform fan out over lists rather than dictionary keys, so the node publishes a sound_list array beside the untouched sounds hash and the pickers read the array. A rejected sound name is usually a custom sound that belongs to a different Pushover account: custom sounds are uploaded to the account that owns the application, and only that application's sounds are valid.
A receipt node returns nothing useful, or fails for a message that was definitely sent
Receipts exist only for messages sent at priority 2. Pushover: Get Emergency Receipt, Pushover: Cancel Emergency Retries and Pushover: Cancel Emergency Retries By Tag have nothing to read or cancel for a message sent at any other priority, and the send node returns a receipt id only when priority was 2. If the priority was right, check where the receipt id came from: Pushover ships no endpoint that lists an application's receipts, so the only source is the send node's own output, which should be templated straight into the receipt node. Receipt data is kept for up to a week after delivery, so an older receipt is gone rather than broken. And if you are polling in a loop, keep to Pushover's documented floor of no faster than once every 5 seconds.
A glance was sent successfully but nothing appeared on the watch
Give it time before treating it as a failure. Pushover states that it may take up to 10 minutes for glance data to reach a widget, because of how the data is delivered and the device's power constraints. After that, check three things. The recipient must have a registered device running the Pushover client, and Apple Watch is currently the only supported widget. At least one of the five data fields has to be supplied, which the node enforces before sending. And check the update rate: watchOS enforces a limit of 50 updates per day and Pushover recommends at least 20 minutes between calls, so a workflow updating a glance every minute will lose most of them.
A workflow cannot read the error detail on a failed licensing call
The errors value changes shape on the licensing endpoint. Everywhere else in Pushover's API it is an array of strings, but licensing returns an object keyed by parameter name, with each parameter mapping to an array of messages, such as a token key whose value says it is out of available license credits. A path expression written for the array form resolves to nothing there. Read the object form on Pushover: Assign License and Pushover: Get License Credits failures. On the substance of that particular error: check the balance with Pushover: Get License Credits before assigning, and do not build an automatic retry, since Pushover recommends raising licensing errors for human intervention rather than retrying, and credits are not refundable.
A delivery group needs to be deleted, or a member is still being paged after being disabled
Pushover exposes no endpoint to delete a delivery group, so an unwanted group has to be removed by hand in the groups editor on pushover.net. That is a vendor limit rather than a gap in this integration, and it is a good reason not to create groups in a loop. For a member who is still being paged, run Pushover: Get Delivery Group and read the membership rows directly: a person can appear in the same group twice with different device restrictions, and disabling or removing without naming the device only affects rows that match. Leave the device field blank on those nodes to affect every row carrying that user key. If the aim was a temporary pause rather than a removal, use Pushover: Disable User In Delivery Group, which keeps the row, the memo and the device restriction and is reversible with Pushover: Enable User In Delivery Group.

Pushover is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products