Menu
Mattering Automations connector

A Healthchecks MCP that spans both halves of the product

23 nodes on Healthchecks.io: create, update, pause, resume and delete checks, read their live status, ping history, diagnostic bodies, status changes, notification integrations and status badges, and send the pings themselves by UUID or by slug. The pinging host answers HTTP 200 even when it recorded nothing, and its not-found body starts with the word OK, so these nodes read the body and fail closed rather than reporting a success that never happened.

23 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Healthchecks MCP connector does

The Healthchecks.io connector for Mattering Automations is 23 nodes, eight that read and fifteen that act. It covers the management API, where checks are created, updated, paused, resumed and deleted and where their status, ping history, diagnostic bodies, status changes, notification integrations and public status badges are read, and it covers the separate pinging host, where the actual signals arrive: success, start, failure, a process exit status and a plain log entry, addressed either by a check's UUID or by the project's ping key and the check's slug.

One connector spans both hosts on purpose, because the workflows worth building cross the boundary. A canvas step can run Healthchecks: List Checks with the management key, branch on the check it finds, and then ping that same check, all on one connection to one project. Splitting the two halves into two connectors would have made the most obvious workflow require two connections to the same account.

Every capability is a node on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. So you can ask an assistant which jobs are currently down, get an answer from Healthchecks: List Checks, and put the same node on a schedule that runs with nobody present.

The most useful thing this connector does is something an integration built by hand usually gets wrong, and it is worth understanding before you choose between the two. The UUID-addressed ping endpoints are deliberately forgiving with status codes, because that URL form is what goes into a crontab and a non-2xx there would turn a monitoring hiccup into a failed job. Healthchecks.io documents two cases plainly: a ping for a check it cannot find answers 200 OK (not found), and a ping dropped for exceeding the rate limit answers 200 OK (rate limited). Worse for anyone checking carefully, that not-found response BODY begins with the letters OK, so a prefix test passes on the failure case just as a status-code test does. An integration that checks either one reports a healthy green while nothing was recorded at all, which is the exact failure a monitoring tool exists to prevent. The slug-addressed endpoints behave differently and better, returning a real not found, a conflict for an ambiguous slug and a real rate-limit code, so the two halves genuinely need different handling.

These nodes parse the response body and compare it exactly, then report what actually happened. Every ping node returns a plain boolean saying whether the ping was recorded and a named outcome such as recorded, created, not found, rate limited, ambiguous slug or an invalid value, alongside the verbatim body so an unrecognised answer is visible rather than swallowed. Anything the connector does not recognise fails closed rather than open, because a monitoring connector that reports green when it does not understand the answer is worse than one that reports red. A ping that never reached Healthchecks.io at all says so in those words, because at that moment the difference between the ping failing and the job failing is the only thing worth knowing.

The highest-value place to point this is at Mattering itself. Dead man's switch monitoring catches the automation that silently stopped running, which is the one failure no error handler inside that automation can catch, because a workflow that never starts raises nothing. End a scheduled workflow with Healthchecks: Ping Success and Healthchecks.io raises the alarm the day it stops arriving. Put Healthchecks: Ping Failure on the error branch and the alert goes out in seconds rather than after the schedule and grace period lapse. Healthchecks: Ping Start at the top of the run buys measured durations and an alert when a job runs longer than its grace period rather than only when it fails to finish.

Healthchecks.io is open source and can be self-hosted, which is unusual in this category and worth knowing when you are choosing a monitor: the vendor says on its own site that Healthchecks is free software and can be self-hosted, under a BSD licence. This connector talks to the hosted service at healthchecks.io and hc-ping.com, so a self-hosted instance is not something you can point it at today. On the hosted service the free tier is called Hobbyist and allows twenty monitored jobs with a hundred log entries kept per job, which is a real allowance rather than a token one, so you can instrument a handful of workflows and see whether the alerting works before anyone pays for anything. Note how the ceiling is counted: the check limit is per account and shared across every project the account owns, while an API key belongs to one project, so one credential here is one project rather than the whole account.

One connection, three surfaces

  • Visual automations. Drag Healthchecks nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Healthchecks node, ready to drop on the canvas

23 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 8

Healthchecks: Get Check

Read one check by its UUID or by the unique_key a read-only API key returns instead. Use it to poll a single job's status without pulling the whole project, or to confirm a change landed after an update. This is one of only two endpoints that accept either identifier, which makes it the read-only path into a single check.

Healthchecks: Get Ping Body

Fetch the diagnostic text a job sent with one specific ping, which is where a failing cron job's log output or stack trace ends up. The response is plain text and is returned verbatim under a body field rather than parsed as JSON. A ping with no stored body answers HTTP 404, the same code as a missing check or a missing ping number, so an absent body is not distinguishable from a bad reference here.

Healthchecks: Get Service Status

Ask Healthchecks.io whether its own database is reachable. Answers HTTP 200 with the body OK when healthy and HTTP 500 when not. This is the one endpoint on the whole API that needs no credential, which makes it the honest way to tell Healthchecks.io being down apart from your key being wrong before an automation escalates. The response is plain text, not JSON, and is returned under a body field.

Healthchecks: List Badges

Get the public badge URLs for every tag in the project, plus a special asterisk entry covering the project as a whole. Each tag comes with six URLs: svg, json and shields for a two-state badge that treats a check in its grace period as still up, and svg3, json3 and shields3 for a three-state badge that reports up, late and down separately. Use these to publish live status into a README, a status page or a dashboard. The URLs are unguessable but unauthenticated, so anyone holding one can read that tag's status. Works with a read-only API key.

Healthchecks: List Checks

List every check in the project, with its current status, its schedule, when it last pinged and when the next ping is due. This is the starting point for most Healthchecks automations: run it on a schedule and branch on any check whose status is down, or use it to find the UUID a ping node needs. There is no pagination on this endpoint and none is possible, so the response holds the whole project every time. Works with a read-only API key, which censors the response: uuid, ping_url, update_url, pause_url, resume_url and channels are removed and a stable unique_key is added in their place.

Healthchecks: List Integrations

List the project's notification integrations with their UUIDs, names and kinds, such as email, sms, slack or webhook. Its main use is feeding the channels field on Healthchecks: Create Check and Healthchecks: Update Check, which wants integration UUIDs or exact names. Also worth running on its own as an audit: an integration nobody remembers configuring is where alerts go to be ignored. Needs a read-write API key; a read-only key cannot reach this endpoint at all.

Healthchecks: List Pings

Read a check's recent ping history, most recent first: what kind of event each ping was, when it arrived, which IP and user agent sent it, its run ID, and how long the run took when a start ping was matched to a finishing one. Use it to chart run durations or to find out what actually happened before a check went down. The number of pings returned is capped by the plan and cannot be paged past: 100 on free accounts and 1000 on paid ones. Older pings are simply not reachable through the API.

Healthchecks: List Status Changes

List the moments a check changed state, up to down or down to up, as a plain time series. This is the endpoint behind uptime reporting and incident timelines: each row is a timestamp and an up value of 1 or 0. Filter it to a trailing number of seconds, or to a start and end range. Retention is the current month plus the two months before it, so a window reaching further back returns nothing rather than failing, and an empty result means either a check that never flipped or a window that is too old. Works with a read-only API key, and accepts the unique_key such a key returns in place of the UUID.

Action nodes 15

Healthchecks: Create Check

Create a check, which is the object a job pings to prove it ran. Give it a timeout for a simple period check, or a cron or systemd OnCalendar expression for a scheduled one; the schedule wins if you send both. This endpoint is also an upsert: fill in the match-on fields and an existing check is updated instead of a second one being created. The status code says which happened, 201 for a new check and 200 for an updated one, and this node surfaces that as a created flag rather than hiding it. On the free plan the 21st check is refused with HTTP 403 and the message that the account has hit its check limit, which the vendor documents as twenty checks per free account.

Healthchecks: Delete Check

Permanently delete a check along with its ping history and its status history. There is no trash and no undo. The UUID dies with it and cannot be reissued, so every ping URL baked into a server for this check stops working, and those servers are told nothing: their pings will keep returning HTTP 200 with a not-found body. The deleted check is returned in the response, which is the only record of it you will get.

Healthchecks: Pause Check

Stop monitoring a check without deleting it, so a planned maintenance window or a decommissioned job does not raise alerts. Put this at the start of a deployment automation and Healthchecks: Resume Check at the end. A paused check normally wakes up on its next ping; a check created with manual resume on stays paused until it is resumed explicitly.

Healthchecks: Ping Exit Status

Report a process exit status and let Healthchecks.io decide what it means: 0 is success, anything from 1 to 255 is a failure. This is the node to use when an upstream step gives you a numeric result and you would otherwise have to branch to pick between the success and failure nodes. A value above 255 is refused by Healthchecks.io with HTTP 400 and the body invalid exit status. Marked destructive for endpoint testing because a non-zero value alerts every integration on the check.

Healthchecks: Ping Exit Status by Slug

Report a process exit status against a check identified by slug and project ping key. Zero records a success and anything from 1 to 255 records a failure and alerts, so a numeric result from an upstream step can be forwarded without branching. Values above 255 are refused with HTTP 400. Marked destructive for endpoint testing because a non-zero value alerts every integration on the check.

Healthchecks: Ping Failure

Report a failure immediately instead of waiting for the check's period and grace to lapse. Put this on the error branch of an automation and an alert goes out in seconds rather than hours, with whatever you put in the ping body attached as the diagnostic. This node sends real alerts to every integration assigned to the check, which is why it is marked destructive for endpoint testing even though it changes no configuration. Reports failure honestly rather than trusting the HTTP 200 this endpoint returns even when nothing was recorded.

Healthchecks: Ping Failure by Slug

Report a failure immediately, addressing the check by slug and project ping key. Put it on an automation's error branch with the error message in the ping body so the alert carries the diagnosis with it. This sends real alerts to every integration assigned to the check, which is why it is marked destructive for endpoint testing. Uses real HTTP status codes: 404 for an unmatched slug, 409 for an ambiguous one, 429 when rate limited.

Healthchecks: Ping Log

Attach a note to a check's event log without changing its status. Use it to record progress through a long job, or to leave a breadcrumb explaining what a run was doing, so that when the check does go down the timeline says why. The check's state and its next-ping deadline are untouched. Reports failure honestly: the vendor's documentation says this endpoint answers 404 for an unknown check, and the live service answers HTTP 200 with a not-found body instead, so this node checks the body either way.

Healthchecks: Ping Log by Slug

Add a note to a check's event log without changing its status, addressing the check by slug and project ping key. Useful for recording progress through a long job so the timeline explains itself if the check later goes down. The check's state and its next-ping deadline are untouched.

Healthchecks: Ping Start

Tell Healthchecks.io a job has just started. Optional, but it buys two things nothing else can: measured run durations, and an alert when a job runs LONGER than its grace period rather than only when it fails to finish. Pair it with a success or failure ping at the end and send the same run ID on both so overlapping runs are matched correctly. A start ping with no matching finish leaves the run open. Reports failure honestly rather than trusting the HTTP 200 this endpoint returns even when nothing was recorded.

Healthchecks: Ping Start by Slug

Signal that a job has started, addressing the check by slug and project ping key rather than by UUID. Gives you measured durations and an alert when a run overruns its grace period. Send the same run ID on the start and the finish so concurrent runs of the same job are paired correctly. Uses real HTTP status codes: 404 for an unmatched slug, 409 for an ambiguous one, 429 when rate limited.

Healthchecks: Ping Success

Tell Healthchecks.io that a job finished successfully. Put this at the end of any Mattering automation that has to run on schedule and Healthchecks.io will raise an alert the day it stops arriving, which is the whole point of dead man's switch monitoring: it catches the automation that silently stopped running, which no error handler can. You can attach diagnostic text as the ping body. This node reports failure honestly: Healthchecks.io answers HTTP 200 even when the UUID matches no check and even when the ping was rate limited, so the node reads the response body and only reports success when the check genuinely recorded the ping.

Healthchecks: Ping Success by Slug

Report a job's success by its human-readable slug instead of its UUID, using the project's ping key. This is the form to reach for when the automation knows the job by name, when checks are created and destroyed by infrastructure so no UUID can be baked in, or when a job should be able to register itself the first time it runs. Unlike the UUID form, this endpoint uses real HTTP status codes: 404 when the slug matches nothing, 409 when it matches more than one check, 429 when rate limited, and 201 when auto-provisioning created the check.

Healthchecks: Resume Check

Put a paused check back into monitoring. Its status returns to new, meaning it is watched again but has not been pinged since resuming. Resuming a check that is not paused is refused with HTTP 409 and the message that the check is currently not in a paused state, so this is safe to run without checking first.

Healthchecks: Update Check

Change an existing check: rename it, retag it, widen its grace period, swap a timeout for a cron schedule, or reassign which integrations it alerts. Only the fields you fill in are sent, so everything left blank keeps its current value. Note the verb: Healthchecks.io updates with POST, not PUT or PATCH, and a PUT to this URL is refused with HTTP 405.

Connecting Healthchecks takes one credential

All three come from the project's settings page in Healthchecks.io, under API access. The first thing to know is that keys are project-scoped: Healthchecks.io states that all API keys are project-specific and that there are no account-wide keys, so one stored credential is one Healthchecks.io project, and monitoring two projects means connecting the connector twice. The second is that the three secrets are genuinely different things rather than three spellings of one. The read-write key reaches every management endpoint. The read-only key reaches only four of them and censors what it returns, omitting the check UUID and its ping, update, pause and resume URLs along with the assigned notification channels, and adding a stable unique key in their place. The ping key is not a header at all: Healthchecks.io puts it into the URL path of the slug-addressed ping endpoints. All three fields are optional, because the useful subsets are real: a read-only reporting credential and a ping-only credential are both legitimate setups.

1

In Healthchecks.io, choose the project you want to connect and open its project settings, where API keys and the ping key are shown.

2

Create or reveal the read-write API key and copy it. Fill this one in first: it is what reaches all thirteen management endpoints, and it is the grade the pickers in this connector need, because a read-only key never returns a check UUID for them to offer.

3

If you want the slug-addressed ping nodes, copy the project's ping key as well. It is optional. The UUID-addressed ping nodes need no credential at all, because a check's UUID is itself the secret that authorises a ping against it.

4

In Mattering Automations, open Connectors, click Add Connector and choose Healthchecks.io. Create a new credential, name it after the Healthchecks.io project it belongs to, and paste the keys into the matching fields.

5

Click Test Connection. The test reports back what the credential can actually do rather than just passing or failing: which key grade it found, how many checks are visible, and what is missing, such as no ping key or a read-only grade. A ping-key-only credential passes with an explicit note that the ping key was not verified, because verifying it would mean sending a real ping to a real check and raising real alerts.

6

All 23 Healthchecks nodes appear in the canvas palette. Run Healthchecks: List Checks first: it takes no parameters, returns the whole project, and gives you the UUIDs and slugs every other node uses.

Common uses for the Healthchecks MCP

Dead man's switch monitoring for your own automations

This is the use worth building first, because it catches a failure nothing else can. End a scheduled Mattering workflow with Healthchecks: Ping Success and Healthchecks.io alerts you the day that ping stops arriving, whether the workflow errored, was disabled, or silently stopped being scheduled. An error handler inside a workflow cannot report a run that never started. Add Healthchecks: Ping Failure on the error branch with the error message as the ping body and the alert goes out in seconds rather than after the period and grace lapse, carrying the diagnosis with it. Add Healthchecks: Ping Start at the top and you also get measured run durations and an alert when a run overruns its grace period, which is how a job that is technically still going but has hung gets noticed.

Checks created and destroyed by the infrastructure that needs them

Healthchecks: Create Check is also an upsert: fill in the fields to match on and an existing check is updated rather than a duplicate created, with the status code telling you which happened. That makes it safe to run from a provisioning workflow that might execute more than once. Pair it with the slug-addressed ping nodes, such as Healthchecks: Ping Success by Slug, and a job never has to know a UUID at all: it reports in by the name it already has, which is the form to reach for when checks are created and torn down with the environments they watch. Healthchecks: Update Check widens a grace period, swaps a timeout for a cron schedule or reassigns which integrations a check alerts, sending only the fields you fill in.

Maintenance windows that do not page anybody

Put Healthchecks: Pause Check at the start of a deployment or migration automation and Healthchecks: Resume Check at the end, and a planned outage stops raising alerts without anyone deleting or reconfiguring a check. Pausing is reversible and cheap, which is exactly what deleting is not. Healthchecks: Resume Check is safe to call unconditionally: resuming a check that is not paused is refused with a clear conflict rather than doing something unexpected, so the end of the workflow does not need to remember what the start of it did.

A status sweep that opens work rather than sending another alert

Healthchecks: List Checks returns every check in the project with its current status, its schedule, when it last pinged and when the next ping is due, in one call with no pagination to walk. On a schedule, that is a whole-estate health sweep: branch on any check whose status is down, and instead of adding to the alert pile, open a task in Mattering Productivity, post a summary to the team channel, or hand the list to an AI step to write a short account of what is broken this morning. Healthchecks: Get Service Status is the honest companion to it and needs no credential at all: before an automation escalates, it can ask whether Healthchecks.io itself is healthy, which separates the monitor being down from the jobs being down.

Incident timelines and run diagnostics

When something did break, three read nodes reconstruct what happened. Healthchecks: List Status Changes gives the moments a check flipped between up and down as a plain time series, which is the raw material for an incident timeline or an uptime report. Healthchecks: List Pings gives the recent ping history most recent first, with the kind of each event, when it arrived, which address and user agent sent it, the run ID and how long the run took when a start ping was matched to a finishing one. Healthchecks: Get Ping Body then fetches the diagnostic text a specific ping carried, which is where a failing job's log output or stack trace ends up. That is enough for an AI step to draft a first-pass explanation before a human opens anything.

Publishing status, and auditing where alerts go

Healthchecks: List Badges returns the public badge URLs for every tag in the project plus one covering the project as a whole, in two-state and three-state variants, so a workflow can publish live job status into a README, an internal status page or a dashboard without anybody copying URLs by hand. Healthchecks: List Integrations lists the project's notification integrations with their names and kinds, which feeds the channels field on Healthchecks: Create Check and Healthchecks: Update Check, and is worth running on its own as an audit: an integration nobody remembers configuring is where alerts go to be ignored.

Example: A nightly data sync that reports its own health honestly

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a nightly schedule fires the sync workflow. This connector has no trigger nodes, so Healthchecks.io is something the workflow reports to and reads from rather than something that pushes to it.

2

Healthchecks: Ping Start tells Healthchecks.io the run has begun, with a run ID generated by the workflow so that overlapping runs are paired correctly. From here the check knows a run is open, so a job that hangs rather than fails is still noticed.

3

The sync itself runs: read the source system, transform, write the destination. Healthchecks: Ping Log can drop a breadcrumb between phases so that if the check later goes down the timeline says which phase it was in.

4

On success, Healthchecks: Ping Success closes the run with the same run ID and a short summary as the ping body, such as how many rows moved. The node reports whether Healthchecks.io actually recorded it rather than trusting the HTTP 200 the pinging host returns either way, so a mistyped UUID surfaces here instead of looking like a healthy night.

5

On the error branch, Healthchecks: Ping Failure fires immediately with the error text as the ping body, so the alert reaches whoever is on call in seconds with the diagnosis attached rather than after the grace period expires.

6

A separate morning workflow runs Healthchecks: List Checks across the project, and for anything whose status is down it runs Healthchecks: List Pings and Healthchecks: Get Ping Body to pull the last diagnostic, then opens one Mattering Productivity task summarising the night rather than sending another alert into a channel that is already noisy.

Healthchecks MCP questions, answered

What can this connector actually do in Healthchecks.io?

23 nodes: 8 read and 15 act. Reads cover listing every check in the project, reading one check, its recent ping history, the diagnostic body of a specific ping, the moments it flipped between up and down, the project's notification integrations, its public status badges, and the Healthchecks.io service's own health. Writes cover creating a check, which is also an upsert, updating one, pausing and resuming one, deleting one, and the ten pinging nodes: success, start, failure, a process exit status and a plain log entry, each in a UUID-addressed form and a slug-addressed form. Not included, because the connector points at the hosted service: anything against a self-hosted Healthchecks instance. Also not included: trigger nodes, since the vendor's API is something you call rather than something that calls you.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and work with Healthchecks.io through them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes are also steps on the automation canvas, so the health sweep an assistant helps you design can then run on a schedule with nobody present. One sensible boundary for an assistant: the reads and the pause and resume nodes are easy to hand over, while Healthchecks: Delete Check and the four failure-reporting ping nodes send real alerts to real people or destroy a UUID that cannot be reissued, so they belong behind a condition or an approval.

Does Healthchecks.io publish its own MCP server?

No first-party MCP server exists. Healthchecks.io is an open-source project with three public repositories and none of them is an MCP server, and the vendor's own documentation and its curated list of third-party resources name none. Community-built servers do exist, and they are unofficial: one of the better known ones says exactly that in its own description. That leaves this connector as the practical way to put Healthchecks.io behind an MCP-capable assistant, and it adds things a locally configured server does not: the same nodes run on a schedule with nobody present, chain with every other connector in one workflow, hold the project's keys once in a shared workspace credential store rather than in each person's local config, and carry destructive flags on the nodes that delete or alert.

Why does a ping need special handling? It returns HTTP 200.

That is exactly the problem, on the UUID-addressed ping endpoints. Those return HTTP 200 whether or not anything was recorded, which is a deliberate design choice on Healthchecks.io's side: that URL form is what goes into a crontab, and a non-2xx there would make a shell script treat a monitoring hiccup as a failed job. The vendor documents two of those cases plainly, a ping for a check it cannot find and a ping dropped for exceeding the rate limit, and both answer 200 with a short explanation in the body. The trap underneath it is that the not-found body begins with the letters OK, so an integration that tests the status code reports success, and an integration that carefully tests whether the body starts with OK also reports success. These nodes compare the body exactly, return a boolean saying whether the ping was recorded along with a named outcome and the verbatim body, and fail closed on anything unrecognised. That is the single biggest reason to use this connector rather than a bare HTTP call. The slug-addressed endpoints are the well behaved half and use real status codes, and the nodes read those honestly too.

Which key do I need, and what does the read-only key change?

There are three secrets on a Healthchecks.io project and they are not interchangeable. The read-write API key goes in the X-Api-Key header and reaches every management endpoint. The read-only API key goes in the same header but reaches only four of them, and it rewrites what it returns rather than merely restricting it: Healthchecks.io omits the check UUID and its ping, update, pause and resume URLs along with the assigned notification channels, and adds a stable unique key instead. That has a consequence worth planning around, because it is a one-way door rather than a permissions message: a read-only credential can never see a UUID, so it can never feed the UUID-addressed ping nodes or any node that takes one. The two nodes that accept either identifier name their field accordingly so a read-only user knows to paste the unique key. The third secret is the ping key, and it is not a header at all: Healthchecks.io puts it in the URL path of the slug-addressed ping nodes. Fill in only what you need. This connector prefers the read-write key even on the four endpoints a read-only key can reach, so that pickers get the UUIDs they need, and it names a grade mismatch in words rather than passing along a bare 401 for a key that was never wrong.

Do the ping nodes need a credential at all?

The five UUID-addressed ping nodes do not. A check's UUID is itself the secret: Healthchecks.io accepts a ping from anyone holding it, with no header authentication on that host whatsoever. That is what makes the URL something you can paste into a crontab, and it is also why a check UUID should be treated as a credential in its own right, since anyone holding one can report success or failure on that job's behalf. The five slug-addressed nodes do need the project's ping key, because a slug is not secret and something has to say which project it belongs to. Those slug-addressed nodes also behave better under failure: they use real HTTP status codes, answering not found for a slug that matches nothing and a conflict for a slug that matches more than one check, where the UUID form answers 200 to everything.

Can I connect a self-hosted Healthchecks instance?

Not through this connector today. Healthchecks.io is open source and genuinely self-hostable, under a BSD licence and with the vendor's own self-hosting documentation, which is a real reason people choose it. But this connector's hosts are fixed to the vendor's hosted service, so the nodes talk to healthchecks.io and hc-ping.com and nothing else. If you self-host, the general HTTP node on the Automations canvas can still call your instance and the API shape is the one documented here, with one difference worth knowing: the forgiving HTTP 200 responses described above are hosted-service behaviour, and the open-source server answers a plain not found instead. So a self-hosted setup needs its own response handling rather than the one these nodes carry. We would rather say this plainly than let you find it at the credential form.

Is the free plan enough to build something real on?

For a first monitoring setup, generally yes. The free tier is called Hobbyist and allows twenty monitored jobs with a hundred log entries kept per job, which is enough to instrument a handful of scheduled workflows and see whether the alerting works before anyone pays. Note how the check limit is counted: it is per account and shared across every project the account owns, while API keys belong to a single project, so connecting two projects is two credentials against one account-wide ceiling. Three limits are worth designing around rather than discovering. Ping history is a count rather than a period, capped at a hundred entries per job on the free tier and a thousand on the paid ones, and there is no way to page past it to older pings, which the node that reads it says on its face. Status change history is kept for the current month plus the two months before it, so asking Healthchecks: List Status Changes for a period further back returns nothing rather than an error, which is ambiguous between a stable check and a window that is simply too old. And the rate limits are worth respecting: the vendor asks that a single check not be pinged more than five times a minute, and that you avoid making more than a hundred management API requests a minute. Check the vendor's current pricing page before designing around any specific number.

Can a workflow start when a check goes down?

Not from this connector directly: it has no trigger nodes, because the vendor's API is something you call rather than something that calls you on its own. The straightforward pattern is polling, and it is cheap here: Healthchecks: List Checks returns the whole project in a single call with no pagination, so a schedule that runs it every few minutes and branches on any check whose status is down is a complete solution for most teams. If you want push rather than poll, Healthchecks.io's own notification integrations include a webhook kind, which can be pointed at a webhook trigger on a Mattering automation. That is configured on the Healthchecks.io side rather than through these nodes, and Healthchecks: List Integrations is what shows you which integrations a project already has.

23 nodes waiting on the canvas

Put Healthchecks to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Healthchecks is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products