Turn a raw API response into a plain-English Slack digest

Your monitoring already works. A Crontap schedule hits https://api.yourservice.com/health every morning at 7, the endpoint returns 200 OK, and the run goes green. Job done. Except the actual answer to "is everything fine?" is sitting inside the response body: forty lines of JSON listing every dependency, queue depth, p95 latency, and cache hit rate. Nobody opens it. The green checkmark says the request succeeded, not that the numbers inside it are healthy. So the payload gets fetched, logged, and ignored, which is a strange place to leave the one thing you scheduled the job to read.

The fix is not another dashboard. It is one readable line in the channel you already stare at all day: "Checkout API is up, Postgres healthy at 38ms, but Redis connections are high and Stripe latency is creeping up, worth a look." Crontap's AI Integrations feature does exactly that. After a scheduled run, it takes that run's response, transforms it with your plain-English prompt, and forwards the result to a webhook you choose. No formatter route, no deploy.

Why the obvious fixes are all awkward

There are three usual ways to get a JSON response into Slack, and all of them are worse than they sound.

Pipe the raw JSON in. You can already forward a run's response to a Slack relay. The result is a code block of forty lines that wraps badly on mobile and that nobody reads on purpose. You have moved the wall of JSON from your logs to your channel. That is not an improvement, that is a spam source you will mute within a week.

Write a formatter route. The "real" engineering answer is a small endpoint that fetches the health JSON, picks out the fields that matter, writes a sentence, and posts to Slack. It works. It is also a new route to host, a deploy to babysit, secrets to manage, and a thing that breaks silently the day the upstream JSON shape changes. You wrote thirty lines of glue to summarize a string. There is a related, heavier version of this pattern (a full backend route per task) that is the right call when you genuinely need it, covered in the scheduled OpenAI pipeline post. For a morning health digest it is overkill.

Use a Zapier "Formatter" step. Zapier and Make are great at moving fields around, but their formatter steps do find-and-replace, math, and date parsing. They cannot read a checks object and write "Redis connections are high." Summarizing prose is the one thing a no-code formatter cannot do, because it is the one thing that needs a language model.

The gap is narrow and specific: you want a model to read this one response and write a human sentence, without you standing up an LLM call yourself.

The shape: an AI Integration on the schedule

Crontap puts an "AI Integrations" card on the schedule form, right next to the webhook "Integrations" card. The flow is one hop longer than a normal run:

Schedule run -> AI transform (your prompt) -> Slack webhook

Concretely:

[Crontap schedule]
   | every morning, 07:00 your timezone
   v
GET https://api.yourservice.com/health   ->  200, {...health JSON...}
   |
   v
[AI transform]  reads THIS run's response body + metadata
   | your prompt: "Summarize this health check in one line."
   v
POST https://hooks.your-relay.com/...     ->  Slack channel

The AI step sees exactly one thing: this run's response. That means the response body (truncated at roughly 100KB) plus the run metadata Crontap already has (the status code, whether the run was ok or failed, how long it took, and the response size). It has no tools, no browsing, and no network access of its own. It cannot call your API again, fetch a second endpoint, or remember last run. It reads the body, applies your prompt, and emits a string.

Because the response body is untrusted input (it could contain anything an upstream API decides to return), it is delimited and wrapped in a hardened system prompt so that text inside the JSON cannot hijack your instruction. The forward URL is validated against SSRF before anything is sent to it. If the transform or the forward fails, the failure lands in Crontap's error tracking as metadata, not as a copy of your response body.

Setting it up (about 60 seconds)

You already have the schedule that hits your health or status endpoint. Open it, find the AI Integrations card, and fill in three things.

1. The prompt. Plain English, describing the line you want back. For a morning digest:

You are summarizing an API health check response for a Slack channel.
Write ONE sentence: is the service up, and are any dependencies
degraded? Name the specific dependency and its number if a value
looks off (high latency, high connection count, error status).
If everything is healthy, say so plainly. No JSON, no markdown.

2. Output format: Text. Text mode returns a plain string, which is what you want for a one-liner. (JSON mode is for structured output, covered further down.)

3. Forward to URL. This is the webhook the result gets POSTed to. Required. For Slack this is usually a relay (more on the why in the worked example), or your Slack incoming webhook if you wire a one-step remap in front of it.

Two optional toggles worth knowing:

• Also run on failure (off by default). Leave it off for a morning "all good" digest. Turn it on if you also want a line when the run itself fails, for example the endpoint returns a 503 or times out.
• Include schedule URL. Adds the schedule's target URL to the forwarded payload, handy when one relay fans out summaries from several schedules and needs to know which service each line is about.

You do not have to pay to try this. The card and its "Perform test" button work on every tier, so you can wire the prompt, run a real test against your endpoint, and see the exact line Slack would get, all before spending anything. AI integrations are a Pro feature: the gate is only at save. Starter can build and test but not save one; Pro can save it (one AI integration per schedule, minimum cadence one day); Ultra is unlimited with a one-hour minimum cadence. Crontap Pro starts at $2.99/mo.

Fix this in 60 seconds with Crontap. Free tier available. No credit card. Schedule your first job →

Worked example: a health check becomes one line

Here is a real-shaped response, following the API health check convention (status, version, a checks object per dependency). This is what your schedule fetches and what nobody reads:

{
  "status": "pass",
  "version": "4",
  "releaseId": "4.18.2",
  "serviceId": "checkout-api",
  "checks": {
    "postgres:responseTime": [
      { "componentType": "datastore", "observedValue": 38, "observedUnit": "ms", "status": "pass" }
    ],
    "redis:connections": [
      { "componentType": "datastore", "observedValue": 87, "status": "warn" }
    ],
    "stripe:responseTime": [
      { "componentType": "component", "observedValue": 612, "observedUnit": "ms", "status": "warn" }
    ],
    "uptime": [
      { "componentType": "system", "observedValue": 1209600, "observedUnit": "s", "status": "pass" }
    ]
  }
}

With the Text-mode prompt above, the AI step emits one string:

Checkout API is up (release 4.18.2): Postgres healthy at 38ms, but
Redis connections are high (87) and Stripe latency is elevated at
612ms, both worth a look.

That string does not get posted to Slack on its own. Crontap wraps it in an envelope and POSTs the envelope to your forward URL:

{
  "aiOutput": "Checkout API is up (release 4.18.2): Postgres healthy at 38ms, but Redis connections are high (87) and Stripe latency is elevated at 612ms, both worth a look.",
  "statusCode": 200,
  "ok": true,
  "durationMs": 287,
  "responseBytes": 1043,
  "verb": "POST",
  "goToUrl": "https://hooks.your-relay.com/checkout-health",
  "timestamp": "2026-06-04T07:00:02Z",
  "url": "https://api.yourservice.com/health"
}

The aiOutput field holds the model's result (a string in Text mode, the parsed object in JSON mode). The statusCode, ok, durationMs, and responseBytes fields are this run's metadata, spread into the envelope. verb and goToUrl describe the forward request, timestamp is the ISO time, and url only appears if you turned on "Include schedule URL."

Here is the one gotcha: Slack's incoming webhook does not render aiOutput. It wants a text field (or a blocks array), and a POST without one comes back as no_text. So you put a one-step relay between Crontap and Slack: a Make or Zapier "Catch Hook" that reads aiOutput from the envelope and posts the tiny payload Slack actually expects.

{ "text": "Checkout API is up (release 4.18.2): Postgres healthy at 38ms, but Redis connections are high (87) and Stripe latency is elevated at 612ms, both worth a look." }

That is the entire relay: one trigger, one Slack action, no code. Crontap does the reading and writing; the relay does the field remap. The same pattern works for team notifications to Teams or Discord, since both accept a similar incoming-webhook payload.

Prompt library (copy, paste, tweak)

Five prompts that cover most digest shapes. Drop one into the AI Integrations prompt field, keep Output on Text, and adjust the nouns.

The "flag only if wrong" prompt pairs nicely with a noisy daily run: most mornings it posts "OK" and you ignore it, the one morning something is off it tells you what, in words.

JSON mode: richer Slack messages

Text mode is perfect for a one-liner. When you want a proper Slack message with a header, a colored status, and a bullet list, switch Output to JSON and describe the shape in the prompt:

Return JSON only, no prose, matching this shape:
{
  "headline": "<short title>",
  "status": "pass | warn | fail",
  "details": ["<short fact>", "<short fact>"]
}
Base every field on the response. Put each degraded dependency
(with its value) in details. headline is a 6-word summary.

In JSON mode the aiOutput in the envelope is the parsed object, not a string:

{
  "aiOutput": {
    "headline": "Checkout API healthy, two warnings",
    "status": "warn",
    "details": [
      "Postgres response time 38ms (pass)",
      "Redis connections high at 87 (warn)",
      "Stripe latency elevated at 612ms (warn)"
    ]
  },
  "statusCode": 200,
  "ok": true,
  "durationMs": 287,
  "responseBytes": 1043,
  "verb": "POST",
  "goToUrl": "https://hooks.your-relay.com/checkout-health",
  "timestamp": "2026-06-04T07:00:02Z",
  "url": "https://api.yourservice.com/health"
}

Now the relay has structure to work with. It maps headline to a Slack Block Kit header, picks an emoji from status, and renders details as a section block. Same Crontap setup, the only difference is Output is JSON and the relay builds blocks instead of a single text string. Use Text when you want a sentence, JSON when you want a card.

When this is the wrong fit

The in-product transform is built for "read one response, write a summary." A few cases sit outside that:

• Huge or binary responses. The body is truncated at roughly 100KB and the model reads text. A multi-megabyte export or a binary blob is the wrong input. Summarize a status or metrics endpoint, not a file download.
• True multi-source roll-ups. The AI step sees one run's response, full stop. It cannot fetch a second endpoint or join three services into one report, because it has no network access of its own. If you need "combine prod, staging, and the billing API," that is a backend job that gathers the data first, then summarizes.
• Anything needing cross-run memory. There is no history in v1: the output is not stored and the model cannot compare today to yesterday ("error rate up 12% week over week"). When you need trends, diffs, or stateful logic, graduate to the DIY pattern in the scheduled OpenAI pipeline post, where your own route owns the data and the comparison. For routing alerts and log lines into chat, the error log triage to Slack post covers a sibling shape.

If your need is "every morning, tell me in one line whether this endpoint is happy," you are squarely in the sweet spot. If it grows teeth (memory, joins, big payloads), that is your signal to reach for a real backend route.

FAQ

Does this work with any JSON endpoint?

Any endpoint your schedule can reach over HTTP. The model reads the response body as text, so JSON, plain text, and most structured formats all work. It does not need to be a "health check": status pages, metrics endpoints, internal /stats routes, and third-party status APIs are all fair game.

Can it post straight to Slack?

Almost. Crontap POSTs an envelope whose main field is aiOutput, and Slack's incoming webhook expects a text (or blocks) field, so a direct post returns no_text. Put a one-step relay (Make, Zapier, or n8n) in between to map aiOutput to text. It is a trigger plus a Slack action, no code.

What about Teams or Discord?

Same shape. Both accept an incoming-webhook style POST. Point the relay's final action at the Teams or Discord webhook instead of Slack and map aiOutput (or the JSON-mode object) into their message format.

How long can the response be?

The body is truncated at roughly 100KB before the transform runs. That is plenty for health, status, and metrics endpoints. If your response is larger than that, summarize a smaller endpoint or trim what your API returns to the fields you care about.

What are the cadence limits?

On Pro you get one AI integration per schedule at a minimum cadence of one day, which fits a daily morning digest. Ultra is unlimited integrations with a one-hour minimum cadence, for hourly status posts. The card and the "Perform test" button work on every tier, so you can validate the prompt before you save anything.

References

• Slack incoming webhooks
• Slack Block Kit
• Health Check Response Format for HTTP APIs (IETF draft)
• Make webhooks

Related on Crontap

• Scheduled AI / LLM jobs use case. The use-case guide for wiring AI into a scheduler.
• Team notifications. Getting the right line into Slack, Teams, or Discord on a schedule.
• Scheduled reports. When the digest grows into a recurring report.

Fix this in 60 seconds with Crontap. Free tier available. No credit card. Schedule your first job →