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.
Connect Pushover to Mattering
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
A send fails saying there is no recipient for this node
An emergency message is rejected, or the node reports that retry and expire are missing
Requests start failing with HTTP 429 partway through a run
The device picker says to choose a user key first, or shows the wrong person's devices
The sound picker is empty, or a sound name is rejected
A receipt node returns nothing useful, or fails for a message that was definitely sent
A glance was sent successfully but nothing appeared on the watch
A workflow cannot read the error detail on a failed licensing call
A delivery group needs to be deleted, or a member is still being paged after being disabled
Related
The Pushover MCP
What connecting Pushover unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
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.