Menu

Mattering Automations Instatus integration

Connect Instatus to Mattering Automations: status pages, components, incidents and their public timelines, maintenance windows, subscribers, metrics, uptime and cron monitors, routing rules and on-call schedules as workflow steps, authorized by an API key from your Instatus developer settings.

The Mattering Automations Instatus integration puts your status page on the automation canvas: create and update status pages and components, open incidents and post the updates that move them through their lifecycle, schedule maintenance windows, post standing notices, record outage periods, manage subscribers and teammates, feed public metric charts, and run the whole monitoring and on-call side including uptime monitors, cron monitors, monitor alerts, routing rules, escalation policies and on-call schedules. 109 nodes in total, 33 that read and 76 that act.

The credential is an API key you create in Instatus and paste into Mattering. Open User settings then Developer settings in the Instatus dashboard, create a key, and add it in Mattering under Connectors with Add Connector. The API is available on every Instatus plan, including the free Starter tier, so getting a key costs nothing.

One thing is worth reading before you build anything, and it is the reason this guide spends a section on it. An Instatus status page is a public web page and its subscribers receive notifications, so several of these nodes have an effect your customers can see the moment they run. Instatus: Create Incident publishes to the live page by default and Instatus: Schedule Maintenance is visible immediately, and any node with notify turned on mails and messages every confirmed subscriber of the affected components. 38 of the 109 nodes carry a destructive flag for exactly this reason, and only 23 of those actually delete anything. The rest of this guide covers the credential, the connect steps, a verify path that publishes nothing, how to work with the parts that do, and the complete node reference.

Before you start

  • An Instatus account. Any plan works, including the free Starter tier: Instatus's pricing page describes API access as available on all plans, and Starter is free forever with no card required.
  • A decision about which Instatus user creates the API key. Instatus issues keys per user rather than per organisation, with no scope selection, so a key carries exactly the access that person has. A key made by an owner can delete any status page in the workspace; a key made by a teammate with access to one page can only touch that page. For unattended automations, an account the team controls beats an individual's login.
  • The Project ID of the status page you want to work with, if you plan to configure nodes by hand. 83 of the 109 nodes take a page id, and Instatus calls it the Project ID in its dashboard rather than the subdomain. In practice you will not need to look it up: every one of those fields is a picker fed by Instatus: List Status Pages.
  • An upgraded status page, if you intend to use the audience-group nodes or Instatus: Regenerate Secure Link. Private and select-audience pages are an upgrade beyond the Starter plan, whose status page type is listed as Public, and those six nodes have nothing to act on without one.
  • A Pro plan, if you need the WELCOME or NONE subscriber confirmation modes, or the autoConfirm override on Instatus: Add Subscriber and Instatus: Add Subscribers In Bulk. Instatus documents all three as Pro only. On any plan, REQUIRED is the default and works.
  • Somewhere safe to test. A throwaway status page with no subscribers on it, which Instatus: Create Status Page will make in one call, lets you run the incident and maintenance nodes for real without an audience watching.
  • A Mattering workspace with access to the Automations app.

Create an Instatus API key

Instatus authenticates with a bearer API key and documents nothing else, so there is no OAuth flow, no scope screen and no per-node permission to configure. The one decision that carries weight is whose key it is, because an Instatus key belongs to a person and inherits that person's access to every status page in the workspace.

Sign in to the Instatus dashboard and open User settings, then Developer settings. The direct address is dashboard.instatus.com/developer.
Create an API key and copy it.
The key carries the full access of the user who made it, with no way to narrow it. If that user is an owner, the key can delete any status page in the workspace, along with its incidents, subscribers and recorded uptime history. Create it as a user whose access matches what your workflows actually need.
Keys are per user rather than per organisation, so an automation running on a departing employee's key stops working when their account goes. A shared account the team controls is the durable choice for anything unattended. Instatus: Get User Profile will tell you at any time whose key a workflow is running as.

Connect Instatus to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Instatus from the list.
Click Create new credential, paste the API key and save it.
The key is stored encrypted in Google Secret Manager and never appears in workflow logs. Deleting the key in Instatus revokes the connection immediately.
Click Test Connection. Mattering asks Instatus for the first page of your status pages, which is the cheapest read on the API and takes no parameters, so a successful response proves the key and the header wiring together.
If the key is rejected, read the HTTP status and not the message. Instatus answers a bad key with a 401 whose body carries a code of forbidden, which is 403 vocabulary. The status line is the one telling the truth: this is an authentication failure, so replace the key rather than hunting for a permission that does not exist.
All 109 Instatus nodes appear in your canvas palette.

Verify it works

Open any automation canvas and check the palette: an Instatus section should list the read and action nodes. Drop Instatus: List Status Pages onto the canvas and run a test step. It is the natural probe for this integration, because it is the node every page picker in the connector is fed from, so a working result here means the pickers work everywhere else. It returns each page's id, name, subdomain, custom domain and current status. The id is the value the other 82 page-scoped nodes want, and it is what Instatus calls the Project ID rather than the subdomain.

An empty array is a valid answer rather than a failure. Instatus keys belong to a person, so a key created by a user with no access to any status page returns an empty list at HTTP 200, and every page picker will then be empty too. If that happens, the fix is in Instatus rather than in Mattering: give that user access to the page, or create the key as a user who already has it.

Now run Instatus: Get Public Page Summary against any Instatus status page, including one you do not own. Give it a page address such as https://instat.us and it returns that page's overall status plus its active incidents and maintenances. This node needs no credential at all, so a result here confirms the node wiring independently of the key, and a result from the previous step plus a result from this one separates a credential problem from a connectivity one. Nothing in this verify path publishes anything or notifies anyone, so it is safe to re-run whenever you want to check the connection.

Node reference

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

Read and query nodes 33

Instatus: Get Audience Group

instatus_get_audience_group

Get one audience group with its teammates fully expanded to their user records, and its components expanded to the full component objects. Read it before updating, because the update endpoint REPLACES the lists it is given rather than adding to them.

Instatus: Get Component

instatus_get_component

Get one component in full: name, description, current status, order, group, uptime-bar visibility and its unique ingest email address. Read a component before updating it so an update changes only what you meant to change, since the update endpoint takes the same field set and an omitted field is not the same as an unchanged one for every field.

Instatus: Get Cron Monitor Summary

instatus_get_cron_monitor_summary

Get a cron monitor's reliability at a glance: total runs, failed runs, overall availability, and one, seven and thirty day availability each paired with the same figure for the previous period so a trend is readable without arithmetic. Also the last success, last failure, last start and how long it has been up or down. These windows are fixed and trailing, with no parameters at all, so this node reports a moving picture and cannot be asked about a historical range; for that, read the logs. The availability figures are percentages with no denominator in the payload, so read and compare them rather than averaging them together.

Instatus: Get General Notice

instatus_get_general_notice

Get one general notice with its name, message in plain text and HTML, notify flag, collapsed flag and timestamps. Read it before updating, since the update endpoint applies only the fields you send.

Instatus: Get Incident

instatus_get_incident

Get one incident with its complete update timeline, the components it affects and their statuses during it, and who raised it. The updates array is the incident's public history in order, so this is the node to read when summarising an outage or when deciding which status transition to post next.

Instatus: Get Incident Update

instatus_get_incident_update

Get one incident update: its message in both plain text and rendered HTML, the status it set, whether it notified subscribers, when it started, and a summary of the incident it belongs to. There is no endpoint that LISTS incident updates on their own, so the ids for this node come from an incident's updates array via Instatus: Get Incident.

Instatus: Get Maintenance

instatus_get_maintenance

Get one maintenance window in full: schedule, duration, current status, every update posted on it, the components it covers and all four notification flags. Read it before updating so a change to the schedule does not silently reset the notification settings, and read it before posting a transition so you do not duplicate one autoStart already made.

Instatus: Get Maintenance Update

instatus_get_maintenance_update

Get one maintenance update: its message in plain text and HTML, the status it set, whether it notified subscribers, when it took effect, and a summary of the maintenance window it belongs to. As with incident updates there is no lister, so the ids come from the window's updates array via Instatus: Get Maintenance.

Instatus: Get Metric

instatus_get_metric

Get one metric with its name, unit suffix, order, active flag and its data points as timestamp and value pairs. Timestamps are epoch MILLISECONDS, not seconds and not ISO strings, which is the same encoding the write endpoints expect. There is no way to request a date range, so this returns the window Instatus chooses.

Instatus: Get Outage

instatus_get_outage

Get one recorded outage period with its start and end, severity, visibility state, the component it belongs to and the incident that produced it. Useful when reconciling a reported availability figure against the specific periods that produced it.

Instatus: Get Public Page Summary

instatus_get_public_summary

Read the public summary any Instatus status page publishes at its own address, with the page's overall status plus its active incidents and active maintenances. Two things make this node different from everything else here. It talks to the status page's own host rather than to the API, and it needs no credential at all, so it works against ANY Instatus page including a vendor's, which makes it the node for watching a supplier you depend on. It also uses the condensed three-value status vocabulary of UP, HASISSUES and UNDERMAINTENANCE rather than the seventeen-value list the authenticated API returns.

Instatus: Get Template

instatus_get_template

Get one template in full: its type, name, message in plain text and HTML, the status it posts, whether it notifies subscribers and which components it changes. Worth reading before an automation posts it, because the template's own notify flag is what decides whether that automation emails your customers.

Instatus: Get User Profile

instatus_get_user_profile

Get the Instatus user the API key belongs to: id, email, name, slug and avatar. An Instatus key is issued to a person rather than to an organisation, so this is how a workflow answers whose key it is running as, and how an audit trail records who an automated incident was posted by.

Instatus: List Audience Groups

instatus_list_audience_groups

List a private status page's audience groups, each with its name, the teammates in it and the components those teammates can see. Audience groups are how one private page shows different services to different customers, so this is the node for auditing who sees what. The path uses a hyphen: audience-groups on reads, audience_groups with an underscore on writes, which is Instatus's own inconsistency.

Instatus: List Components

instatus_list_components

List the components on a status page with each one's id, name, description, current status, display order, group and whether it shows an uptime bar. Components are the individual services the page reports on, and their ids are what incidents, maintenances, subscriptions and audience groups attach to, so this is the lookup most other nodes in this connector depend on. Each component also carries a uniqueEmail address: sending mail to it raises an incident on that component, which is how Instatus ingests alerts from tools with no integration.

Instatus: List Cron Monitor Logs

instatus_list_cron_monitor_logs

Read a cron monitor's check-in history: each ping with its status, the HTTP method used, the user agent and source address, when it arrived and when the job said it started. The status vocabulary tells you what actually happened: SUCCESS and FAILURE are pings the job sent, MISSED means nothing arrived inside the window, LATE means it arrived after the period but inside the grace, and STARTED is the opening half of a paired start and finish ping. Filter to important rows only, and bound the range with ISO 8601 dates; Instatus defaults to the last year. The limit here caps at 127 and the page number at 1000, which are the vendor's own numbers.

Instatus: List Cron Monitors

instatus_list_cron_monitors

List the cron monitors on a status page: scheduled jobs that prove they ran by pinging Instatus, so a job that stops running is caught by its silence rather than by a failed request. Each row carries its expected period and grace in SECONDS, its current status, its state of ACTIVE, PAUSED or MUTED, the component it reports against, its ping slug and its full onFail and onRecover behaviour. Filter by status to find jobs that have missed their window.

Instatus: List Escalation Policies

instatus_list_escalation_policies

List a status page's escalation policies with their ordered rules, each rule's delay in minutes, its condition and the actions it takes, plus the policy-level repeat settings. An escalation policy is the answer to nobody picked up: rule one pages the on-call engineer, rule two waits ten minutes and pages their backup, and repeat decides how many times the whole ladder runs before autoResolveIncidentsAfterRepeat gives up. Takes no pagination parameters.

Instatus: List General Notices

instatus_list_general_notices

List the general notices on a status page. A general notice is a persistent banner that is not an incident and not a maintenance, which makes it the right shape for a standing announcement such as a migration window, a deprecation or holiday support hours. Each one carries its name, message in plain text and HTML, whether it notified subscribers and whether it renders collapsed.

Instatus: List Incidents

instatus_list_incidents

List a status page's incidents with each one's name, opening and resolution timestamps, current status, full update timeline, affected components and the workspace member who created it. Filter to or away from particular statuses with the status and exclude_status fields, so a workflow can ask for open incidents only without reading the whole history. The user field is null when the incident was created automatically by a monitor, a third-party integration or an inbound email, which is how you tell machine-raised incidents from human ones.

Instatus: List Maintenances

instatus_list_maintenances

List a status page's maintenance windows with each one's name, scheduled start, duration in minutes, current status, its update timeline and its notification settings. The notifyEarly and notifyMinutes pair is the advance warning subscribers get; autoStart and autoEnd say whether Instatus moves the window through its lifecycle on the schedule by itself. Listed on /v2, read individually on /v1.

Instatus: List Metrics

instatus_list_metrics

List the metrics charted on a status page, each with its name, unit suffix, display order, active flag and its recorded data points as timestamp and value pairs. Note that the data points come back inside the metric rather than from a separate endpoint, and there is no date-range parameter anywhere on this API, so you get whatever window Instatus decides to return and cannot ask for a different one.

Instatus: List Monitor Alerts

instatus_list_monitor_alerts

List the monitor alerts configured on a status page, each with its channel, recipient, which state changes it fires on, its SSL expiry warning window and the monitors attached to it. An alert is the delivery half of monitoring: a monitor decides something is wrong and an alert decides who hears about it and how. Read this to audit who is being paged. Rows arrive under a monitorAlerts key with total, page, totalPages and limit alongside.

Instatus: List Monitor Logs

instatus_list_monitor_logs

Read the individual check results for one monitor: when each ran, from where, whether it succeeded, the HTTP status it saw, and the timing breakdown of DNS, TCP, TLS, first byte, download and total response time. This is the node for latency investigation and for proving what actually happened during an outage. Filter by date range, location, success, status or HTTP code. Read the timings as a series rather than adding them up: each row is one measurement, so summing response times means nothing and averaging them across days is only honest when each day contributed the same number of checks.

Instatus: List Monitors

instatus_list_monitors

List the uptime monitors on a status page with each one's target URL, type, assertions, check interval, monitoring locations, alerts and its onFail and onRecover behaviour. Filter by status to find what is currently broken. This lister populates every monitor picker in the connector. Note the response shape and the pagination differ from the versioned half of this API: rows arrive under a monitors key alongside total, page, totalPages and limit, and the page size parameter is limit rather than per_page.

Instatus: List On-call Schedule Members

instatus_list_on_call_schedule_members

Read who is on call on a schedule right now, who is up next, and everyone in the rotation, each with their id, name, email, phone and avatar. This is the node that answers who do I contact, so it is the one worth wiring into a Matter agent or an incident-response workflow. Note that Instatus ships no endpoint that lists SCHEDULES, so the schedule id has to come from a create response or from the dashboard URL.

Instatus: List Outages

instatus_list_outages

List the recorded outage periods on a status page: the from and to timestamps, the component affected, the severity, whether the period is published, and the incident it came from when there was one. Outages are the underlying record the uptime bars and uptime percentages are computed from, which makes this the node to read for real availability reporting rather than for the current status. An outage with a null incident was recorded directly rather than raised through the incident flow.

Instatus: List Routing Rules

instatus_list_routing_rules

List a status page's routing rules with their assertions and actions in order. A routing rule matches on an incoming event's title, description, impact or affected components and then notifies a team, a named workspace member, or whoever is currently on call. This is the node for auditing who gets paged for what, and the order field is significant. Takes no pagination parameters at all, unlike most of this API.

Instatus: List Status Pages

instatus_list_pages

List the status pages your Instatus API key can see, with each one's id, name, subdomain, custom domain, current derived status and branding. This is the node the rest of the connector leans on: every page picker is populated from it, and it is the cheapest way to confirm a credential works. The id it returns is what Instatus calls the Project ID and what every other node here wants. Note the response is a bare JSON array with no total, so paginate by asking for the next page until one comes back empty. This list also carries the secure link for any private page you have member or owner access to.

Instatus: List Subscribers

instatus_list_subscribers

List the people subscribed to a status page, with each one's email or phone number, webhook target, whether they have confirmed, and whether they follow the whole page or specific components. Search by email address or phone number to check whether a particular customer is subscribed. This payload is personal data: it is a customer contact list, so treat what a workflow does with it accordingly.

Instatus: List Teammates

instatus_list_teammates

List the people with access to a status page, each with their teammate id and their user record of name, email and avatar. The teammate id, not the user id, is what audience groups and the remove endpoint take, and the two are different values in the same payload, so read carefully. Note the path segment is team rather than teammates.

Instatus: List Templates

instatus_list_templates

List the saved incident and maintenance templates on a status page, with each one's type, name, message, the status it posts, its notify flag and the component statuses it applies. The type field is INCIDENT or MAINTENANCE and it decides which endpoints will accept the template, so read it before wiring one into an automation. This node also populates every template picker in the connector.

Instatus: List Workspaces

instatus_list_workspaces

List the Instatus workspaces your key belongs to, with each one's name, slug, the status page ids it contains, its SSO and directory-sync state, allowed email domains and the default notification settings applied to new members. A workspace is the billing and membership container above status pages, so this is where you look to find which pages sit together.

Action nodes 76

Instatus: Add Incident Update

instatus_create_incident_update

Post an update to an open incident. This is the node that moves an incident through its lifecycle the way customers expect: the status you set here becomes the incident's status AND appears as a dated entry on the public timeline explaining the change. Posting RESOLVED closes the incident. The update is on the public page as soon as this returns, because an update always belongs to an incident that is already there, and turning notify on emails and messages every confirmed subscriber of the affected components. The statuses list can move component colours at the same time, which is how you take a component back to OPERATIONAL as part of resolving.

Instatus: Add Incident Update From Template

instatus_create_incident_update_from_template

Post an incident update from a saved template, most often the resolution message. The template supplies the wording, the status and the component statuses, so an automation that watches a monitor recover can close the incident with the exact words your team agreed on. The template's own notify setting decides whether subscribers hear about it. This is the only operation in the incident-update family on /v2; its siblings are all on /v1, which is Instatus's split rather than a mistake here.

Instatus: Add Maintenance Update

instatus_create_maintenance_update

Post an update on a maintenance window, which is how the window moves from NOTSTARTEDYET to INPROGRESS to COMPLETED with an explanation attached. Use it to say the work has started, that it is running long, or that it finished early. The entry is on the public page immediately, and notify emails and messages every confirmed subscriber of the affected components. If the window has autoStart or autoEnd on, Instatus will also move it by itself, so pick one mechanism rather than both.

Instatus: Add Metric Data Point

instatus_add_metric_datapoint

Push one data point onto a metric chart. The timestamp is epoch MILLISECONDS, so 1608672985000 rather than 1608672985, and a value in seconds lands in 1970 and quietly ruins the chart's axis. The point appears on the public chart immediately. Note the path: a POST to the metric itself adds a point, while a POST to the metric's /data adds many, so the two write endpoints differ only by that segment.

Instatus: Add Metric Data Points In Bulk

instatus_add_metric_datapoints_bulk

Push many data points onto a metric chart in one call, which is the node for backfilling history or for a scheduled job that reports a batch of measurements at a time. Every timestamp is epoch MILLISECONDS. The response echoes the accepted points, so compare its length against what you sent rather than assuming the whole batch landed.

Instatus: Add Monitors To Group

instatus_add_monitors_to_group

Put monitors into a group. Instatus documents this as adding the listed monitors and returns only a success message, so confirm the outcome with Instatus: List Monitors rather than assuming whether the list added to the group or replaced its membership; the response says nothing either way.

Instatus: Add Subscriber

instatus_add_subscriber

Subscribe an email address or phone number to a status page, either to everything or to named components only. What happens next is decided by the page's subscriberConfirmationMode: REQUIRED sends a confirmation request they must accept, WELCOME adds them at once and sends a welcome email, NONE adds them silently, and the last two are Pro plan only. Setting autoConfirm on this call overrides the page setting for this one subscriber and behaves like NONE. Either way a real message may reach a real person, so do not point this at a list you have no consent for. Marked Destructive for endpoint testing on exactly that basis.

Instatus: Add Subscribers In Bulk

instatus_add_subscribers_bulk

Subscribe up to 100 people to a status page in one call. Each entry takes the same fields as the single-subscriber node, so a batch can mix whole-page and per-component subscriptions and mix email with SMS. Partial success is normal and is reported honestly: the response carries created and failed counts plus a results object listing each created subscriber and each failure with its index, the entry that failed and an error code such as creation_failed for a duplicate. Check the failed array rather than trusting the HTTP status. autoConfirm applies to the whole batch and is Pro plan only.

Instatus: Add Teammate

instatus_add_teammate

Give someone access to a status page by email address. This sends them an invitation, so it reaches a real inbox the moment it runs, and it grants edit rights over a public page: the person can post incidents customers will see. Marked Destructive for endpoint testing because it mails a real person, not because it deletes anything.

Instatus: Create Audience Group

instatus_create_audience_group

Create an audience group on a private status page, pairing a set of teammates with the components they are allowed to see. This is an access-control write: it decides which customers see which services on a shared private page. Note the underscore in the path. Instatus creates and updates audience groups under audience_groups while listing, reading and deleting them under audience-groups, and this catalog carries both spellings verbatim because either substitution returns 404. The response is a thin record without the teammates and components expanded; read the group back if you need those.

Instatus: Create Component

instatus_create_component

Add a component to a status page. It appears on the public page as soon as this returns, so a component created with a status other than OPERATIONAL announces a problem the moment it is created. To nest it under an existing group, set grouped to true and group to the group's id. Reads are on /v2 and this create is on /v1, which is Instatus's own split.

Instatus: Create Cron Monitor

instatus_create_cron_monitor

Create a cron monitor for a scheduled job. period is how often the job should report in and grace is how much late is still acceptable, BOTH IN SECONDS, so a daily job with an hour of slack is 86400 and 3600. The response carries a slug, which is what your job pings; the background check starts on the first successful ping, so a monitor created and never pinged does not immediately alarm. As with uptime monitors, the onFail object decides whether a missed run raises a PUBLIC incident and notifies subscribers.

Instatus: Create Escalation Policy

instatus_create_escalation_policy

Create an escalation ladder for unacknowledged incidents. Each rule waits delayInMins, checks its condition, then runs its actions, and the rules fire in order. The only condition Instatus documents is NOT_ACKNOWLEDGED. Two policy-level settings deserve a decision rather than a default: revertAcknowledgement takes an incident back to unacknowledged so the ladder can run again, and autoResolveIncidentsAfterRepeat closes the incident once the ladder has run out of people to page, which resolves an incident nobody actually fixed. Creating a policy pages nobody; the next unacknowledged incident does.

Instatus: Create General Notice

instatus_create_general_notice

Add a standing banner to a status page for something that is neither an incident nor a maintenance: an upcoming migration, a deprecation, changed support hours. The banner is visible to visitors as soon as this returns. Unlike incidents, notify here defaults to false in Instatus's own documentation as well as in this node, so a notice is quiet unless you deliberately announce it.

Instatus: Create Incident

instatus_create_incident

Open an incident on a status page. Read the two flags before wiring this into anything automatic. shouldPublish defaults to TRUE, which is Instatus's own default, so unless you set it to false the incident is on the public page the moment this returns. notify sends email, SMS and chat notifications to every confirmed subscriber of the affected components, and it starts off here because Instatus documents no default for it. Together those two decide whether this call is a private draft or a customer announcement. The status field sets the opening state of the lifecycle, normally INVESTIGATING; every later transition should be posted as an incident update so the public page gets a timeline entry explaining it. Naming components attaches them; the statuses list is what actually changes their colour. Marked Destructive for endpoint testing because it can mail a real subscriber list, not because it deletes anything.

Instatus: Create Incident From Template

instatus_create_incident_from_template

Open an incident from a saved template, taking its name, message, opening status, affected components and their statuses from the template rather than from this node's config. This is the node for a rehearsed response: the wording was agreed in advance and the automation only decides when to post it. The template must be of type INCIDENT. Everything the template carries applies, including its own notify setting, so check the template before wiring this to a trigger. Returns the raw incident record rather than the hydrated shape the other incident nodes return.

Instatus: Create Metric

instatus_create_metric

Create a metric chart on a status page, such as response time or requests per minute. The chart appears publicly as soon as this returns and stays empty until data points are pushed to it, so create it and feed it in the same workflow rather than leaving a blank chart on a customer-facing page.

Instatus: Create Monitor

instatus_create_monitor

Create an uptime monitor that checks a URL on a schedule from chosen regions and asserts on the response. The two objects worth reading before wiring this to anything are onFail and onRecover: they decide whether a failing check CREATES A PUBLIC INCIDENT, publishes it and notifies subscribers, and whether a recovery resolves it again. A monitor created with onFail.publishIncident and onFail.notifySubscribers on is a standing instruction to tell your customers about an outage without a human in the loop, which is usually the point and is occasionally a very expensive mistake. createComponent and createMetric add a component and a response-time chart to the public page alongside the monitor. Note that pageId goes in the BODY here, because the create path carries no page segment.

Instatus: Create Monitor Alert

instatus_create_monitor_alert

Create an alert that delivers monitor state changes to a person or channel. The type decides the delivery route and the recipient is read in terms of it: an email address for EMAIL, a phone number for SMS or PHONE_CALL, a channel or webhook target for the chat types. INCIDENT is different from all of them, because it raises an incident on the status page rather than messaging anybody directly. Creating the alert sends nothing; the first matching monitor state change does. whenSslExpires with sslExpiresInDays is the certificate warning, which is the one alert here that fires on a schedule rather than on a failure.

Instatus: Create Monitor Group

instatus_create_monitor_group

Create a group to organise monitors, optionally nested under another group. Groups collapse a long monitor list into something readable and can be paired with a component on the public page. Note the path spelling: monitors-groups, plural on both words. Instatus ships no endpoint that lists groups, so record the id this returns; nothing else will give it back to you through the API.

Instatus: Create Monitoring Integration

instatus_create_monitoring_integration

Connect a third-party monitoring tool such as Pingdom or New Relic to a status page, so alerts from that tool land on named components. This is the family that arms automatic incident creation from outside Instatus: once it exists, an alert from the connected tool can put an incident on the public page with nobody in the loop. These are the only three operations on /v3 in the entire API, which is Instatus's own versioning and not a typo here. Instatus documents no endpoint that LISTS integrations, so record the id this returns.

Instatus: Create On-call Schedule

instatus_create_on_call_schedule

Create an on-call schedule with one or more shifts, each holding its own members, rotation and time restrictions. This is the richest body in the connector and it is nested three deep: a schedule holds shifts, a shift holds members and time intervals. Rotation is DAILY, WEEKLY or CUSTOM, and a CUSTOM rotation needs customRotationTypeValue and customRotationTypeUnit. Restrictions are NONE for round the clock, TIMEOFDAY for the same hours every day, or TIMEINTERVALS for named day and time spans such as Saturday 21:00 to Sunday 03:00. Record the id this returns: there is no endpoint that lists schedules.

Instatus: Create Routing Rule

instatus_create_routing_rule

Create a rule that decides who gets notified about an incoming event. Assertions match on the event, actions say who to notify, and order decides which rule wins. Note two shapes specific to this family. The whole body is WRAPPED in a routingRule object, which this node does for you. And an action's targetId means different things per action type: a workspace member EMAIL ADDRESS for NOTIFY_WORKSPACE_MEMBER, a team id for NOTIFY_TEAM, and nothing at all for the on-call types, which resolve their target from the schedule. Creating a rule notifies nobody; the next matching event does.

Instatus: Create Status Page

instatus_create_page

Create a new status page with its first components in one call. The page goes live at subdomain.instatus.com as soon as this returns, so pick the subdomain deliberately: it is the public address customers will see. Passing a list of component names creates those components alongside the page, which is the quickest way to stand up a working page. Note the version split here is real and not a typo: pages are LISTED on /v2 and CREATED on /v1.

Instatus: Create Template

instatus_create_template

Save a reusable incident or maintenance template so a response can be posted later in wording your team agreed in advance. Creating a template publishes nothing and notifies nobody; the notify flag stored here takes effect when the template is POSTED. The components field on this endpoint is a list of OBJECTS carrying an id, a status and optionally a customImpactPercentage, which is different from the plain list of id strings the incident and maintenance endpoints take.

Instatus: Create Workspace

instatus_create_workspace

Create a workspace to hold status pages and members, and set the notification defaults every new member inherits. Useful for agencies and platform teams standing up a separate container per client or per product line.

Instatus: Delete Audience Group

instatus_delete_audience_group

Permanently delete an audience group. There is no trash and no undo, and everyone in the group loses the scoped view it gave them. Back to the HYPHEN spelling here: delete uses audience-groups while create and update use audience_groups.

Instatus: Delete Component

instatus_delete_component

Permanently delete a component from a status page, along with its recorded uptime history. There is no trash and no undo, and any subscriber who subscribed to that component specifically loses that subscription. If the goal is to stop showing a component while keeping its history, update it with archived set to true instead. Reads are on /v2 and this delete is on /v1.

Instatus: Delete Cron Monitor

instatus_delete_cron_monitor

Permanently delete a cron monitor and its ping history. There is no trash and no undo, and the ping slug stops working, so the job carries on pinging into nothing. Nobody is told the job is now unwatched. If the goal is to quieten it temporarily, update its state to PAUSED or MUTED instead.

Instatus: Delete Escalation Policy

instatus_delete_escalation_policy

Permanently delete an escalation policy and its whole ladder. There is no trash and no undo. Incidents that would have escalated through it now do not escalate at all, which is a failure you discover during the next outage rather than now.

Instatus: Delete General Notice

instatus_delete_general_notice

Permanently delete a general notice, removing the banner from the public page. There is no trash and no undo. This is the normal way to take a notice down once the thing it announced is over.

Instatus: Delete Incident

instatus_delete_incident

Permanently delete an incident and every update on it. There is no trash and no undo, and the incident disappears from the public history as though it never happened, which changes the page's uptime record. Notifications already sent to subscribers are not recalled. Deleting is for incidents raised in error; a real incident that is over should be RESOLVED rather than removed.

Instatus: Delete Incident Update

instatus_delete_incident_update

Permanently remove one entry from an incident's public timeline. There is no trash and no undo. Deleting the most recent update does not roll the incident's status back to what the previous entry said, so an incident can be left claiming a status nothing on its timeline explains. Notifications already sent for that update are not recalled.

Instatus: Delete Maintenance

instatus_delete_maintenance

Permanently delete a maintenance window and every update on it. There is no trash and no undo. If subscribers already received the advance warning, deleting the window does not tell them it is cancelled: post a maintenance update saying so first, then delete, or the calendar entry they made stands.

Instatus: Delete Maintenance Update

instatus_delete_maintenance_update

Permanently remove one entry from a maintenance window's public timeline. There is no trash and no undo, and removing the most recent entry does not roll the window's status back, so it can be left claiming a state nothing on its timeline explains.

Instatus: Delete Metric

instatus_delete_metric

Permanently delete a metric and every data point recorded against it. There is no trash and no undo, and the chart disappears from the public page. To clear the numbers while keeping the chart, use Instatus: Delete Metric Data Points instead.

Instatus: Delete Metric Data Points

instatus_delete_metric_datapoints

Permanently delete the data points on a metric while keeping the metric itself. There is no trash, no undo and no way to delete a single point or a range: this clears the series. Use it when a bad feed has poisoned a public chart and the fastest honest fix is to empty it and re-push.

Instatus: Delete Monitor

instatus_delete_monitor

Permanently delete a monitor and its check history. There is no trash and no undo. Checking stops at once, which means the thing it watched is now unwatched and nothing will say so: a deleted monitor produces silence, not an alert. Any component or metric it created on the public page is left behind.

Instatus: Delete Monitor Alert

instatus_delete_monitor_alert

Permanently delete a monitor alert. There is no trash and no undo. The monitors it covered keep running and keep recording failures; they simply stop telling anyone through this route, so the symptom of a wrong delete here is silence during the next outage rather than an error now.

Instatus: Delete Monitor Group

instatus_delete_monitor_group

Permanently delete a monitor group. There is no trash and no undo. Instatus does not document what becomes of the monitors inside it, so treat their fate as unknown and confirm they are still running afterwards with Instatus: List Monitors rather than assuming they were simply ungrouped.

Instatus: Delete Monitoring Integration

instatus_delete_monitoring_integration

Permanently disconnect a third-party monitoring tool from a status page. There is no trash and no undo. The external tool keeps monitoring and keeps alerting its own way; what stops is those alerts reaching this status page, so the visible symptom is a page that no longer reflects an outage the tool can see. Returns an empty object on success.

Instatus: Delete On-call Schedule

instatus_delete_on_call_schedule

Permanently delete an on-call schedule and every shift on it. There is no trash and no undo. Any routing rule or escalation policy action of type NOTIFY_CURRENT_ON_CALL_USER, NOTIFY_NEXT_ON_CALL_USER or NOTIFY_ALL_ON_CALL_MEMBERS resolves its target from a schedule, so deleting one can leave those actions with nobody to page, and they will not say so until an incident needs them. Returns HTTP 204 with an empty body, so a successful run shows data as an empty object.

Instatus: Delete Outage

instatus_delete_outage

Permanently delete a recorded outage period. There is no trash and no undo, and the component's published uptime percentage goes UP as a result, because the downtime it was counting stops existing. That makes this the one delete in the connector that improves a public number, which is exactly why it deserves a deliberate hand on it. Returns HTTP 204 with an empty body, so a successful run shows data as an empty object.

Instatus: Delete Routing Rule

instatus_delete_routing_rule

Permanently delete a routing rule. There is no trash and no undo. Events that matched it now fall through to whatever rule comes next, or to nothing, so the consequence of a wrong delete here is an unattended incident rather than an error message.

Instatus: Delete Status Page

instatus_delete_page

Permanently delete a status page. This takes the public page offline and removes its components, incidents, maintenances, metrics, subscribers and recorded uptime history with it. There is no trash and no undo, and the subdomain stops resolving immediately for anyone who has the link. Same path shape as the update: /v2/{page id}, no /pages segment.

Instatus: Delete Template

instatus_delete_template

Permanently delete a saved template. There is no trash and no undo. Nothing already posted from it changes, but any automation that references this template id starts failing, which is the failure mode worth checking for first: the template is a dependency of every workflow that posts it.

Instatus: Delete Workspace

instatus_delete_workspace

Permanently delete a workspace. This is the widest-blast-radius call in the connector: a workspace contains status pages, and those pages carry their own incidents, subscribers and history. There is no trash and no undo. Confirm the workspace has no pages you still need before running it.

Instatus: Edit Incident Update

instatus_update_incident_update

Edit an update already on the public timeline: fix its wording, its status, its timestamp or the component statuses it applied. Customers who already read the original or received it by email see no correction unless you turn notify on, so an edit is not a retraction. For a material change of story, post a new update rather than rewriting history.

Instatus: Edit Maintenance Update

instatus_update_maintenance_update

Edit an update already on a maintenance window's public timeline: its wording, status, effective time or the component statuses it applied. Subscribers who already received the original are not told about the correction unless notify is turned on.

Instatus: Ping Cron Monitor Failure

instatus_ping_cron_monitor_fail

Tell Instatus a scheduled job failed, explicitly and immediately, rather than waiting for its window to lapse. Put this on the error branch of an automation so a failure is reported the moment it happens instead of up to a period plus a grace later. This applies the cron monitor's own onFail behaviour, so on a monitor configured to publish and notify it raises a public incident and messages subscribers. Marked Destructive for endpoint testing on that basis.

Instatus: Ping Cron Monitor Start

instatus_ping_cron_monitor_start

Tell Instatus a scheduled job has started. Pair it with a success or failure ping at the end and Instatus records how long the run took, which turns a cron monitor from did it run into how long did it take. Sending a start ping with no matching finish leaves the run open, so put the finishing ping on every branch that ends the job, including the error branch.

Instatus: Ping Cron Monitor Success

instatus_ping_cron_monitor

Tell Instatus a scheduled job finished successfully. Put this at the end of any Mattering automation that has to run on time, and Instatus will notice when it stops arriving. The slug is the secret: it comes back from Instatus: Create Cron Monitor and from Instatus: List Cron Monitors, and anyone who has it can report on that job's behalf, so treat it as a credential rather than as an id. The first successful ping is what starts the background check, so a new cron monitor is not armed until this runs once.

Instatus: Record Outage

instatus_create_outage

Record a downtime period against a component directly, without an incident. This is the backfill node: it is how you enter history from before you used Instatus, or correct a period the monitors missed. Recording an outage CHANGES THE PUBLISHED UPTIME PERCENTAGE for that component, so it is publicly visible in the numbers even when visibilityState keeps the period itself out of the timeline. It sends no notifications.

Instatus: Regenerate Secure Link

instatus_regenerate_secure_link

Mint a new secure link for a private status page and invalidate the old one. Everyone holding the previous link loses access the moment this returns, which is the point when a link has leaked and also the reason not to run it casually. The page must be private with secure links enabled, and your account needs member or owner access to it. The link embeds a JWT, so treat the returned value as a credential.

Instatus: Remove Subscriber

instatus_remove_subscriber

Unsubscribe somebody from a status page. They stop receiving notifications immediately and there is no undo: resubscribing them means a new confirmation cycle. This is the node to use for an unsubscribe or deletion request, and it is also the node that quietly cuts a customer off from outage notices if pointed at the wrong id.

Instatus: Remove Teammate

instatus_remove_teammate

Remove somebody's access to a status page. Their access ends immediately. Incidents and updates they already posted stay on the page and keep their name attached. Pass the TEAMMATE id from the list endpoint, which is the outer id, not the nested user id.

Instatus: Run Monitor Check

instatus_run_monitor_check

Run one monitor's check immediately instead of waiting for its schedule, optionally from a named region. This is a GET that DOES something, which is why it sits with the actions. It sends a real request to the monitored target, and if the check fails the monitor's own onFail behaviour applies, so a monitor configured to publish and notify can raise a public incident as a result of this call. Use it to confirm a fix has landed before the next scheduled check.

Instatus: Run Monitor Group Check

instatus_run_monitor_group_check

Run every monitor in a group immediately, optionally from a named region. Another GET that does something, which is why it sits with the actions. Each monitor's own onFail behaviour applies, so this can raise several public incidents at once if the group is configured that way and the target is genuinely down. Useful after a deploy to confirm a whole surface is healthy without waiting for the schedule.

Instatus: Schedule Maintenance

instatus_create_maintenance

Schedule a maintenance window on a status page. It is visible to visitors as soon as this returns, and it is expanded on the page by default; set isCollapsed to true with an expandAt time to have it appear quietly and open itself closer to the window. Four separate notification switches decide who hears what and when: notify announces the schedule now, notifyEarly with notifyMinutes warns subscribers that many minutes before it starts, notifyStart tells them it has begun and notifyEnd tells them it is over. autoStart and autoEnd move the window from NOTSTARTEDYET to INPROGRESS to COMPLETED on the schedule with no further API calls, so an automation that also posts those transitions will produce them twice unless the flags are off. Marked Destructive for endpoint testing because it can mail a real subscriber list.

Instatus: Update Audience Group

instatus_update_audience_group

Update an audience group's name, components or teammates. A list sent here REPLACES the existing one rather than adding to it, so read the group first and send the full intended set, or you will silently revoke access for everyone you left out. Underscore in the path, as on create.

Instatus: Update Component

instatus_update_component

Update a component's name, description, status, order, grouping or archived flag. Changing status is publicly visible immediately and recalculates the page's overall status, so setting MAJOROUTAGE here turns the page red without creating an incident or telling anyone why. For a customer-facing outage, prefer creating an incident with a statuses entry, which sets the component status AND leaves a timeline explaining it. Note the group field is spelled group on create and groupId here.

Instatus: Update Cron Monitor

instatus_update_cron_monitor

Update a cron monitor's name, schedule, grace, alerts or behaviour, or change its state. The state field is the useful one for automation: PAUSED stops checking entirely and MUTED keeps checking while sending no notifications, which is how you silence a known-broken job during a planned migration without losing its history. Remember that period and grace are seconds.

Instatus: Update Escalation Policy

instatus_update_escalation_policy

Update an escalation policy's name, ladder or repeat settings. The rules list replaces the existing ladder rather than merging with it, so send the whole thing: a short list silently removes the later rungs, and the way you find out is that nobody was paged after the first one did not answer.

Instatus: Update General Notice

instatus_update_general_notice

Update a general notice. Instatus applies only the fields you send, so this is a genuine partial update and omitting a field leaves it alone. The edit is live on the public page immediately.

Instatus: Update Incident

instatus_update_incident

Edit an incident record: its title, start time, affected components and their statuses. Understand what this does NOT do before using it to move the lifecycle along. Changing status here edits the record without adding a timeline entry, so a page can end up reading RESOLVED with no message saying how it was resolved. To move an incident from INVESTIGATING to IDENTIFIED to MONITORING to RESOLVED the way customers expect, post an incident update instead. Use this node for corrections: a wrong title, a wrong start time, a component that should not have been attached.

Instatus: Update Maintenance

instatus_update_maintenance

Reschedule or edit a maintenance window: its title, times, duration, notification flags and covered components. As with incidents, changing status here edits the record without adding a timeline entry, so use a maintenance update when you want the public page to say WHY the window started late or ran long. Moving the start time of a window whose advance warning has already gone out does not un-send it.

Instatus: Update Metric

instatus_update_metric

Rename a metric or change the unit suffix shown after its values. The change is live on the public chart immediately. Changing the suffix does not convert the stored numbers, so relabelling milliseconds as seconds makes the chart wrong rather than converted.

Instatus: Update Monitor

instatus_update_monitor

Update a monitor: its target, method, headers, assertions, check interval, region, alerts or its onFail and onRecover behaviour. Turning onFail.publishIncident or onFail.notifySubscribers ON here is a customer-facing change even though nothing is published by this call: the next failed check is what acts on it, unattended.

Instatus: Update Monitor Alert

instatus_update_monitor_alert

Update a monitor alert's channel, recipient, trigger conditions or the monitors it covers. The monitors list REPLACES the existing one, so sending a short list silently stops alerting for every monitor left out, which is a failure that announces itself only by nothing happening during the next outage. Read the alert first.

Instatus: Update Monitor Group

instatus_update_monitor_group

Rename a monitor group, collapse it, reorder it or pair it with a component on the public status page. Nothing here is visible to customers except the component pairing, which decides which public component the group's monitors report against.

Instatus: Update Monitoring Integration

instatus_update_monitoring_integration

Update a monitoring integration: any field the create endpoint takes, plus a display label and the two template objects that customise what an incoming alert actually says. createTemplate shapes the incident this integration opens and resolveTemplate shapes how it closes, which is how you stop a third-party tool posting raw alert text on a customer-facing page.

Instatus: Update On-call Schedule

instatus_update_on_call_schedule

Update an on-call schedule's name, description, status or shifts. Instatus's own example sends the ENTIRE schedule back, ids and all, including every shift, member and time interval, so the safe pattern is to read the schedule, change what you need and send the whole object rather than a partial one. Dropping a shift or a member from that object takes them off the rotation, which means nobody is paged for the window they used to cover.

Instatus: Update Outage

instatus_update_outage

Correct a recorded outage period: its severity, its start, its end or its visibility. Closing an open period by setting to is the common case. Every one of these edits moves the published uptime percentage for the component, so treat it as a correction to a public number rather than as an internal edit.

Instatus: Update Routing Rule

instatus_update_routing_rule

Update a routing rule's assertions, actions or evaluation order. As with create, the body is wrapped in a routingRule object. The lists replace rather than merge, so a short actions list quietly stops paging everyone left out, and the symptom is nobody being woken up during the next incident. Read the rule first with Instatus: List Routing Rules.

Instatus: Update Status Page

instatus_update_page

Update a status page's name, subdomain, branding, custom HTML and CSS, privacy settings and subscriber confirmation behaviour. Note the path: this operation is /v2/{page id} with no /pages segment at all, which is Instatus's own spelling and not an omission here. Changing the subdomain changes the public address customers already have, so treat it as a migration rather than an edit.

Instatus: Update Template

instatus_update_template

Edit a saved template's type, name, message, posted status, notify flag or component statuses. Nothing is published and nobody is notified by this call. Changing the notify flag changes the behaviour of every automation that posts this template afterwards, which is the one edit here with a customer-facing consequence.

Using the integration

Which nodes your customers can see

This is the part of the integration to understand before anything else, because a status page is a public web page usually linked from a product's footer, and its subscribers receive email, SMS and chat notifications. Two flags decide most of it. shouldPublish on Instatus: Create Incident defaults to true, which is Instatus's own documented default, so an incident is on the live page the moment the node returns unless you set it to false. This integration preserves that default rather than quietly inverting it, on the grounds that a workflow author who read Instatus's docs and expected publication should not be surprised by a connector that helpfully flipped it. The notify flag appears on incidents, incident updates, maintenances, maintenance updates and templates, and it mails and messages every confirmed subscriber of the affected components. Instatus documents no default for notify anywhere, so this integration declares it explicitly on every request and starts it off, because an undocumented default that mails a customer base is not something to discover in production. General notices are the exception in the other direction: Instatus documents notify as defaulting to false for those, and Instatus: Create General Notice keeps the vendor's default. Beyond those two flags, three more things are customer-visible with no notification attached: Instatus: Update Component changes the page's colour immediately and recalculates the overall status, Instatus: Create Metric puts a chart on the page that stays empty until you feed it, and a monitor whose onFail behaviour is set to publish and notify is a standing instruction to announce an outage with no human in the loop.

Reading the destructive flag correctly

38 of the 109 nodes are flagged destructive, and it is worth knowing what that flag means here, because it is wider than deletes data. Only 23 of the 38 delete anything. The other 15 delete nothing at all: they publish to a live page, mail a real person, or invalidate something someone is using. Instatus: Create Incident, Instatus: Create Incident From Template, Instatus: Update Incident, Instatus: Add Incident Update, Instatus: Add Incident Update From Template, Instatus: Edit Incident Update, Instatus: Schedule Maintenance, Instatus: Update Maintenance, Instatus: Add Maintenance Update, Instatus: Edit Maintenance Update, Instatus: Add Subscriber, Instatus: Add Subscribers In Bulk, Instatus: Add Teammate, Instatus: Ping Cron Monitor Failure and Instatus: Regenerate Secure Link are the fifteen. Mailing a subscriber list is not reversible in any way that matters, which is exactly the property the flag is there to mark. Every one of those nodes carries the reason in its own description, so the warning arrives while you are configuring it. Among the 23 real deletes, two deserve a second look before automation. Instatus: Delete Outage is the only delete in the connector that improves a public number, because removing a recorded downtime period raises the component's published uptime percentage. And Instatus: Delete Workspace has the widest blast radius of anything here, since a workspace contains status pages and those pages carry their own incidents, subscribers and history.

Moving an incident through its lifecycle

An incident runs INVESTIGATING, IDENTIFIED, MONITORING, RESOLVED, and a maintenance window runs NOTSTARTEDYET, INPROGRESS, COMPLETED. Neither is enforced as a strict progression, so any status can be posted at any time. What is not interchangeable is where you set it, and this is the most useful thing to learn about the integration. Instatus: Create Incident sets the opening status only. Every transition after that should be Instatus: Add Incident Update, because that is what produces a dated entry on the public timeline explaining the change. Instatus: Update Incident will also change the status field, but it adds no timeline entry, which is how a page ends up reading RESOLVED with nothing on it explaining how it was resolved. Use it for corrections instead: a wrong title, a wrong start time, a component that should not have been attached. Maintenance windows work the same way and add one wrinkle: autoStart and autoEnd move a window through its lifecycle on the schedule with no API call at all, so a workflow that also posts Instatus: Add Maintenance Update transitions will produce each one twice unless those flags are off. Two more behaviours are worth knowing. Naming components on an incident attaches them, but the statuses list is what actually changes their colour, which is how you take a component back to OPERATIONAL as part of a resolution. And deleting the most recent update does not roll the parent's status back to what the previous entry said, so Instatus: Delete Incident Update can leave an incident claiming a status nothing on its timeline explains.

Page ids, pickers, and the fields that are not sent

Most paths in this API are scoped to a status page, so page_id is a first-class parameter: 83 of the 109 nodes take one. Every one of those fields is a picker fed by Instatus: List Status Pages, labelled with the page name and decorated with its subdomain, and the child pickers for components, incidents, maintenances, templates, metrics, subscribers, audience groups, general notices, outages, teammates, monitors, monitor alerts, cron monitors and escalation policies use the chosen page as their parent, so they populate once you pick a page and repopulate when you change it. The value Instatus wants is the Project ID from its dashboard, not the subdomain, which is the most common thing to get wrong when configuring by hand. Ten nodes in the monitoring and on-call families carry a page_id field that is never sent to Instatus at all, and each of those field descriptions says so rather than leaving a mystery in the panel. The reason is structural: Instatus's update, delete, log and run endpoints for monitors carry no page context, but their listers are page-scoped, so the inert field is what gives the child picker a parent to list from. Five id fields are free text on purpose. Monitor group ids, monitoring integration ids and on-call schedule ids have no picker because Instatus ships no endpoint that lists them, so record the id the create node returns. Incident update and maintenance update ids come from the parent's updates array, which Instatus: Get Incident and Instatus: Get Maintenance already return. Routing rule ids are the odd one: a lister exists, but a routing rule carries no name or description of any kind, so a picker could only offer two identical ids, and free text is the honest answer until Instatus adds a name field.

The node that needs no credential

Instatus: Get Public Page Summary is the exception to everything else in this guide. It reads the summary that every Instatus status page publishes at its own address rather than calling the API, and it sends no Authorization header at all, so it works against any Instatus page including one belonging to a vendor you have no relationship with. Give it a status page URL with no trailing path and it returns that page's overall status plus its active incidents and active maintenances. That makes supplier monitoring a first-class workflow rather than a stretch: run it on a schedule against the status pages your product depends on, and react to an upstream outage in your own tools before your support queue tells you about it. Two details to plan around. The status vocabulary on this endpoint is the condensed three-value list of UP, HASISSUES and UNDERMAINTENANCE, not the longer list the authenticated API returns for a page, so a condition written against one will not match the other. And it only works for pages hosted by Instatus, since it reads Instatus's own published format rather than scraping a page.

Monitors, cron monitors and making a job prove it ran

The monitoring half of Instatus is fully covered here and it is where automation pays off fastest. Instatus: Create Monitor sets up a check against a URL from chosen regions with assertions on the response, and the two objects to read before wiring it to anything are onFail and onRecover, because they decide whether a failing check creates a public incident and notifies subscribers, and whether a recovery resolves it again. Instatus: Run Monitor Check runs one immediately rather than waiting for the schedule, which is useful after a deploy, and it is worth knowing that it is a GET that genuinely does something: it sends a real request to the target and the monitor's own onFail behaviour applies to the result. Cron monitors solve the failure that alerting usually misses, which is a job that stops running entirely and therefore produces no error. Create one with Instatus: Create Cron Monitor, where period and grace are both in seconds, then put Instatus: Ping Cron Monitor Success at the end of any Mattering automation that has to run on time. Add Instatus: Ping Cron Monitor Start at the beginning and Instatus records how long each run took; put Instatus: Ping Cron Monitor Failure on the error branch and a failure is reported immediately rather than when the window lapses. Treat the ping slug as a credential rather than an id, because anyone holding it can report on that job's behalf. Two listers here are windowed rather than paged: Instatus: List Monitor Logs and Instatus: List Cron Monitor Logs both take date bounds, and the monitor log rows carry a full timing breakdown of DNS, TCP, TLS, first byte and download time that is worth reading as a series rather than summing.

Pagination, and the half of this API with no totals

This API has two pagination conventions and they do not agree, which matters when you write a loop. The versioned endpoints, which is most of the connector, take page and per_page, default to 50 rows and cap at 100, and return a bare JSON array. There is no total and no page count anywhere in that response, so there is no way to know from one call whether more rows exist: you ask for the next page and stop when one comes back empty. The monitoring endpoints take limit instead of per_page, default to 100, and return an object with the rows under a named key alongside total, page, totalPages and limit, so there you can tell. Routing rules and escalation policies take no pagination parameters at all. Each node is one request and this integration does not auto-paginate, which is deliberate: an unbounded walk never hides behind a single canvas step, and the decision to fetch another page is yours. Instatus does not document a rate limit in its API reference, so this guide is not going to invent a number for it. An HTTP 429 is reported as a throttle rather than as a credential failure, and retrying shortly is the right response.

On the automation canvas

Instatus nodes chain with every other node in Mattering, which is where the value is: detection almost never lives in the same place as the status page. A webhook from an alerting tool, a failed health check earlier in a workflow, or a spike in a support queue can all run Instatus: Create Incident, and Instatus: Create Incident From Template is the better shape once the wording is agreed, because then the automation decides only when to post and not what to say. A change calendar or an approved Productivity task can call Instatus: Schedule Maintenance with the components attached and the advance warning already set. A scheduled read of Instatus: Get Public Page Summary against a supplier can drive Instatus: Update Component on your own page. And Instatus: List On-call Schedule Members, which answers who is on call now and who is next, is worth wiring into a Matter agent so anybody can ask without opening the dashboard. There are no trigger nodes in this integration, so Instatus workflows run on a schedule or off another system's event. Instatus can deliver notifications to a webhook subscriber, so a status page can be pointed at a webhook trigger in Mattering, but that is a subscription configured on the Instatus side rather than a node in this list.

From AI assistants over MCP

Every node 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. Instatus publishes no MCP server of its own: its help site and API reference describe the REST API and do not mention MCP or the Model Context Protocol anywhere. That means there is no vendor server to weigh this against, and the arguments for running Instatus here rather than in a local assistant config are the ordinary ones plus one that matters more on a public status page. The nodes run on a schedule or off another system's event with nobody present, they chain with every other connector so an alert from your monitoring becomes an incident here in one workflow, the credential lives once in a shared workspace store rather than in each person's machine, and the 38 nodes that publish, mail or delete are flagged before anyone runs them. Given what this connector can put in front of customers, the sensible split is to hand an assistant the 33 read nodes freely and put the writes behind a condition or an approval step. An agent that can answer what is currently broken and who is on call is useful with no risk attached. An agent holding Instatus: Create Incident with notify on is a different decision, and one to make deliberately.

Subscribers, teammates and audience groups

These three families all decide who sees or hears something, and each has a behaviour worth knowing before you automate it. Instatus: Add Subscriber may email a real person: what happens is decided by the page's subscriberConfirmationMode, where REQUIRED sends a confirmation request and is the default on every plan, while WELCOME adds them at once with a welcome email and NONE adds them silently, both documented by Instatus as Pro only. The autoConfirm override on the create nodes is Pro only too. Instatus: Add Subscribers In Bulk takes up to 100 people in one call and reports partial success honestly, with created and failed counts and a results object naming each failure and its index, so check the failed array rather than trusting the HTTP status. Instatus: List Subscribers returns a customer contact list, so treat what a workflow does with that payload accordingly. On the teammate side, Instatus: Add Teammate sends an invitation email and grants edit rights over a public page, so the person invited can post incidents customers will see, and Instatus: Remove Teammate takes the teammate id rather than the nested user id, which are two different values in the same payload. Audience groups pair a set of teammates with the components they are allowed to see on a private page, which makes them an access-control surface: Instatus: Update Audience Group replaces the lists it is given rather than adding to them, so read the group first and send the full intended set or you will silently revoke access for everyone left out.

Troubleshooting

Test Connection fails with a 401 whose message says forbidden
Read the status, not the message. Instatus answers a rejected key with an ordinary HTTP 401 while the body carries a code of forbidden, which is 403 vocabulary and misleads anyone who greps the body first. The status line is correct: this is an authentication failure, not a permission one, so there is no scope to widen and no setting to change. Create a fresh key in the Instatus dashboard under User settings then Developer settings and paste it again. The most common causes are a key that was deleted in Instatus, a partial paste, or a key belonging to a user account that has since been removed from the workspace.
The connection tests fine but every page picker is empty
This is expected behaviour rather than a fault, and it is specific to how Instatus issues keys. A key belongs to a person, not to an organisation, so it can authenticate perfectly and still see nothing. Instatus: List Status Pages returns an empty array at HTTP 200 for a user with no access to any status page, and because every page picker in the connector is fed from that node, they all come up empty together. Run Instatus: Get User Profile to confirm whose key you are actually using, then either give that user access to the page in Instatus or create the key as a user who already has it. The fix is always on the Instatus side.
A node fails with a 404 even though the ids look right
Check the page id first. Instatus wants what its dashboard calls the Project ID, a long identifier you copy from the project menu, and not the subdomain, so a page id of status or acme will 404 every time. Use the picker rather than typing it: every page-scoped field in this integration is fed from Instatus: List Status Pages, and the value it supplies is the right one. If the page id is definitely correct, check that the child id belongs to that page, since an id from a different status page returns a 404 rather than a permission error. Note also that a few families have no lister on the Instatus side, specifically monitor groups, monitoring integrations and on-call schedules, so those ids are typed by hand and are worth re-checking against the create response or the dashboard URL they came from.
An automation published something to the live status page unexpectedly
Two flags account for almost all of these. shouldPublish on Instatus: Create Incident defaults to true, which is Instatus's own default and is preserved here rather than silently inverted, so an incident is public the moment the node returns unless you set that field to false. And notify, which appears on incidents, incident updates, maintenances, maintenance updates and templates, mails and messages every confirmed subscriber of the affected components. Two less obvious paths do the same thing. A template carries its own notify setting, so Instatus: Create Incident From Template and Instatus: Add Incident Update From Template publish and notify according to the template rather than according to the node, which means checking the template with Instatus: Get Template before wiring it to a trigger. And a monitor whose onFail behaviour is set to publish and notify will raise a public incident on its own schedule with nobody present, including as a result of Instatus: Run Monitor Check. Nothing already sent to subscribers can be recalled, so build and test on a throwaway page with no subscribers before pointing a workflow at the real one.
The status page shows RESOLVED but the timeline does not explain how
The status was changed with Instatus: Update Incident instead of Instatus: Add Incident Update. Updating the incident record changes the status field and adds no entry to the public timeline, so the page reads as resolved with nothing on it saying so. Post an incident update to fix it, which sets the status and leaves a dated entry at the same time, and switch the workflow to use that node for every transition. Reserve Instatus: Update Incident for corrections to the record itself: a wrong title, a wrong start time, a component that should not have been attached. The same applies to maintenance windows through Instatus: Add Maintenance Update. One related case looks identical and has a different cause: deleting the most recent update with Instatus: Delete Incident Update does not roll the incident's status back to what the previous entry said, so a delete can produce exactly this state too.
A maintenance window posted every transition twice
The window has autoStart or autoEnd turned on and the workflow is also posting the transitions. Instatus moves a window from NOTSTARTEDYET to INPROGRESS to COMPLETED on the schedule by itself when those flags are set, with no API call involved, so an automation adding its own updates duplicates them. Pick one mechanism. Leaving the flags on and letting Instatus drive the lifecycle is the simpler choice, with Instatus: Add Maintenance Update reserved for the things a schedule cannot know, such as the work running long or finishing early. Read the window with Instatus: Get Maintenance to see the current flag values before changing anything, and note that Instatus: Update Maintenance can reset notification settings if you send a partial body, so read before you write.
Adding a subscriber did not behave the way the page setting says
Three plan-related behaviours account for this and Instatus documents all of them. The page's subscriberConfirmationMode governs what happens by default: REQUIRED sends a confirmation request the person must accept and is the default on every plan, WELCOME adds them immediately with a welcome email, and NONE adds them immediately with no email. WELCOME and NONE are documented as Pro only, so on a free plan the mode falls back to a confirmation request. The autoConfirm field on Instatus: Add Subscriber and Instatus: Add Subscribers In Bulk overrides the page setting for that request and behaves like NONE, and it is Pro only as well. If you are on Starter, expect a confirmation request every time. Separately, on the bulk node, partial success is normal: check the failed array and the results object in the response rather than the HTTP status, since a duplicate address comes back as a per-entry error with a code of creation_failed while the call as a whole succeeds.
The audience group or secure link nodes have nothing to act on
Those six nodes need an upgraded status page. Instatus's pricing table lists the Starter status page type as Public, and its own tooltip explains that changing a page to private or select audience is an upgrade, with the Business plan including three upgraded pages of any type. Audience groups exist to show different services to different customers on a private page, and Instatus: Regenerate Secure Link requires a private page with secure links enabled and member or owner access to it, so on a public page there is simply nothing there. This is a plan boundary rather than a fault in the connection. One more thing to know about that family if you do use it: Instatus spells the path with a hyphen when listing, reading and deleting audience groups and with an underscore when creating and updating them, and this integration carries both spellings exactly as documented because either substitution returns a 404.
A metric chart is empty or its axis looks wrong
Timestamps on metric data points are epoch milliseconds, not seconds. A value in seconds is interpreted as a moment in 1970, which does not error and does not appear on the visible range, so the chart looks empty or its axis stretches back fifty years. Multiply by 1000 and re-push. If a bad feed has already landed, Instatus: Delete Metric Data Points clears the series while keeping the chart and its position on the page, which is faster than deleting and recreating the metric. Two related notes. A metric created with Instatus: Create Metric is on the public page immediately and stays empty until something feeds it, so create and feed it in the same workflow rather than leaving a blank chart in front of customers. And there is no date-range parameter anywhere on the metrics endpoints, so a read returns whatever window Instatus chooses rather than one you can ask for.
A list node seems to be missing rows, or a loop never ends
This API paginates two different ways and the difference is the usual cause. The versioned endpoints, which is most of the connector, return a bare JSON array with no total and no page count, so there is no way to tell from one response whether more rows exist: request the next page and stop when one comes back empty. Their page size defaults to 50 and caps at 100. The monitoring endpoints behave differently, taking limit rather than per_page, defaulting to 100, and returning an object with total, page, totalPages and limit alongside the rows, so a loop there can be bounded properly. Routing rules and escalation policies take no pagination parameters at all and return everything. This integration does not auto-paginate on purpose, so each node is exactly one request and the decision to fetch more is yours.
A monitor was deleted or a group was changed and nothing reported it
Silence is the expected symptom for most failures on the monitoring side, which is what makes them worth checking deliberately. Deleting a monitor stops its checks at once, so the thing it watched is now unwatched and nothing will say so. Deleting a monitor alert leaves the monitors running and recording failures while nobody is told through that route. Deleting an escalation policy or a routing rule means the next incident does not escalate or route at all. Two behaviours here are genuinely undocumented by Instatus rather than merely quiet, and the node descriptions say so rather than guessing: what happens to the monitors inside a group when the group is deleted, and whether Instatus: Add Monitors To Group adds to the group's membership or replaces it. In both cases the response is only a success message, so confirm the outcome with Instatus: List Monitors afterwards rather than assuming.

Instatus 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