Own every alert, from firing to fixed.

Sigtake ingests alerts from all your systems, collapses duplicates into one row, and routes what matters to the right team — by email, Slack, Microsoft Teams or in-app.

Start free Read the docs

Free during early accessNo credit card

API
UPTIME
SIGNAL
SSL

Alerts

PAYMENTS

API|Payment webhook timeout|CRITICAL
API|Payment webhook timeout|CRITICAL
API|Payment webhook timeout|CRITICAL
API|Payment webhook timeout|CRITICAL
API|Payment webhook timeout|CRITICAL
API|Payment webhook timeout|CRITICAL×25

PLATFORM

UPTIME|Database latency|WARNING
SIGNAL|High error rate|WARNING

WEB

SSL|Certificate expiring|ACKNOWLEDGED

Slack #alerts-prod
Email
Microsoft Teams

Nobody reads the alert channel anymore

One incident arrives forty-seven times, nothing says who is on it, and the alert that mattered scrolled past at 3am.

#alerts-prodToday

02:58CPU above 92% on prod-web-03
03:01CPU above 92% on prod-web-03
03:04CPU above 92% on prod-web-03
03:07CPU above 92% on prod-web-03
03:10CPU above 92% on prod-web-03
03:13CPU above 92% on prod-web-03

+ 41 more · no owner · nobody acknowledged

Alert centerWith Sigtake

CRITICAL CPU above 92% on prod-web-03 ×47

MRAcked by Marta Ruiz · 2m · team Infrastructure

02:58CPU spikes on prod-web-03. The channel starts repeating it.
05:16Forty-seven messages later: no owner, nobody acknowledged.
SigtakeOne row that counts. One owner who has it.

One row per incident, not forty

The whole loop between “it fired” and “it’s fixed”: ingestion, deduplication, routing and acknowledgement.

One fingerprint per incidentSource, title and severity decide what counts as a repeat, scoped to one project. Staging and production stay two incidents.
Notified at 1, 10, 25, 50 and 100Then every hundredth. Forty-seven repeats are three notifications, not forty-seven.
Acknowledge, discuss and resolve in the incidentComments with @mentions, and updates that stream in live so everyone sees the same thing.

The API key picks the projectProduction and staging keys land alerts in their own project. There is no project id to pass.
The team_code picks the teamEvery alert belongs to one team. Teams can span projects.
The team’s channels in that project deliver itConfigure a channel once and reuse it across teams with per-team toggles.

Sigtake alert detail: Payment webhook timeout, critical, firing, fired ×25 since first seen, team Payments, with activity showing it fired again 24 times.

One pipeline, from any source to the right team

Alerts you send and the checks Sigtake runs for you take the same path: deduplicated, routed, delivered.

Alerts API & SDKs
Uptime checks
SSL expiry
Signal rules
Heartbeats

Deduplicatesource · title · severity

PAYMENTS
PLATFORM
WEB

Email
Slack
Microsoft Teams
In-app

Anything that can POST: Prometheus, Datadog, Grafana, Sentry, Zabbix, cron, a webhook.

Monitoring that files its own alerts

Watch your endpoints and your numbers from the same place you work the incidents. A failed check or a broken threshold becomes a real alert, deduplicated and routed like every other.

Sigtake website monitor for Public API: 100% uptime over 24 hours, 7 and 30 days, a 90-day uptime bar, response time chart, and an SSL certificate that expires in 7 days. — **Website & SSL**Checks every 60 seconds on status, latency and the response body, with JSONPath assertions and encrypted secret headers for authenticated endpoints. Certificates get their own alert 14 days ahead, with reminders at 7, 3 and 1.

Sigtake signal for the orders worker: queue depth readings over 24 hours with anomaly detection active and a spike well above normal. — **Signals**Push any number with `signals.send()`. Thresholds over a window (avg, sum, count, min, max or last), anomaly detection that learns normal for the hour and weekday, and a missing-signal rule that fires when a metric stops reporting.

Know when a scheduled job goes quiet

Cron jobs, backups, queue workers: anything that should run tells Sigtake when it does. If it goes quiet, fails or hangs, the team hears about it.

Its real scheduleAn interval or a cron expression in its timezone, plus a grace window before anything fires.
Start, finish and exit codePing /start before and the exit code after. Every run gets a duration; a failure, an overrun or a run that never finishes alerts.
Jobs with no scheduleWorkers and functions run on demand: they alert on a reported failure or a run that takes too long, never on silence. Each run is tracked on its own.
A missed ping is a normal alertDeduplicated, routed to the team’s channels, and resolved when the job runs again.
A secret URL you can rotateRotate it and keep the old one working for an hour, a day or a week. Only operators and admins see it.

Why cron jobs fail silently, and how to catch it

nightly-backup · 03:00 UTC · 5 min grace

0 3 * * * curl -fsS -m 10 --retry 3 -o /dev/null https://api.sigtake.com/ping/<token>/start; /usr/local/bin/backup.sh; curl -fsS -m 10 --retry 3 -o /dev/null https://api.sigtake.com/ping/<token>/$?

204 No ContentEvery ping answers empty, so cron has nothing to mail.

BASE is the heartbeat’s ping URL

const rid = randomUUID();
const ping = (path) => fetch(`${BASE}${path}?rid=${rid}`,
  { signal: AbortSignal.timeout(5000) }).catch(() => {});

await ping('/start');
try {
  await job();
  await ping('');
} catch (err) {
  await ping('/fail');
  throw err;
}

204 No ContentEvery ping answers empty, and a failed ping never fails the job.

CRON-CHECK|Heartbeat down: nightly-backupHIGH

Cause: No ping received in time
Schedule: 0 3 * * * (UTC), 5 min grace
Team: PLATFORM

Live in five minutes

Three steps from sign-up to the first alert reaching your team.

Create an API keyIn your project, under API Keys. The key decides which project an alert lands in.
Create a team and attach a channelThe team gets a code like K7Q2XD. Attach email, Slack or Microsoft Teams; in-app is always on.
Send your first alertOne request with the team’s code. It shows up live and reaches the team’s channels.

Get your API key No credit card

npm install @sigtake/sdk

import { Sigtake } from '@sigtake/sdk';

const sigtake = new Sigtake({ apiKey: process.env.SIGTAKE_API_KEY });

await sigtake.alerts.ingest({
  title: 'Payment webhook timeout',
  severity: 'critical',
  source: 'payments-api',
  team_code: 'K7Q2XD',
});

pip install sigtake

import os
from sigtake import Sigtake

with Sigtake(api_key=os.environ["SIGTAKE_API_KEY"]) as sigtake:
    sigtake.alerts.ingest(
        title="Payment webhook timeout",
        severity="critical",
        source="payments-api",
        team_code="K7Q2XD",
    )

POST /api/ingest

curl -X POST https://api.sigtake.com/api/ingest \
  -H "X-Api-Key: $SIGTAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Payment webhook timeout",
    "severity": "critical",
    "source": "payments-api",
    "team_code": "K7Q2XD"
  }'

201 CreatedOpen in Sigtake and on its way to the Payments team.

Official SDKs for Node and Python: zero dependencies, typed, ESM + CJS, sync and async · npm · PyPI · GitHub

Light on purpose

Sigtake skips the parts that make incident tools heavy: rotas to keep current, escalation trees to configure, pager apps to install. What’s left is live in five minutes.

Teams, not rotationsEvery alert reaches the whole team that owns it. No schedule to maintain, and nobody missed because last week’s rota was never updated.
Repeats bring it backAn alert that keeps firing notifies again at 10, 25, 50 and 100 occurrences. Urgency follows the incident, with no escalation policy to write.
Where your team already worksEmail, Slack, Microsoft Teams and in-app. No pager app to roll out, no phone numbers to collect.

Coming from Opsgenie? See how the concepts map

Start free, scale when you’re paged

Everything’s free while we’re in early access: unlimited users, teams and alerts, plus website, signal and heartbeat monitoring, no credit card. Paid plans will come as we grow.

$0per month, per organization

The whole product, for as long as early access lasts.

Start free See what’s included

Unlimited users, teams and projectsWith as many API keys as your systems need.
Unlimited alert ingestionDeduplicated into incidents, with occurrence counts.
Email, Slack, Microsoft Teams and in-appEvery channel we ship, on every team.
Website, signal and heartbeat monitoringUptime and SSL checks, thresholds and anomaly detection on signals, and Heartbeats for cron jobs and workers.
Node and Python SDKsTyped, zero dependencies, sync and async.

You hear it by email firstPricing changes are announced to every organization owner before they take effect, never discovered inside the product.
Nothing you configured is deletedProjects, teams, channels, API keys and alert history stay exactly where they are while you decide.
Nothing can be charged silentlyThere’s no card on file to charge. A paid plan starts when you choose one, not when a trial expires.

Before you ask

Do I have to replace my current monitoring?

No. Sigtake sits downstream of what you already run. Anything that can send an HTTP request with its own JSON body can post an alert: a cron job, a CI step, the SDKs. Tools with a fixed webhook format, like Alertmanager, need a small relay in between.

How does it decide two alerts are the same incident?

A fingerprint over source, title and severity, scoped to one project. The same failure in staging and production stays two separate incidents.

Who gets notified?

The team named by the alert’s team code, through that team’s channels in the alert’s project. In-app always lands, so nothing is lost while a channel is misconfigured.

Can it tell me when a cron job stops running?

Yes. Give the job a Heartbeat: one line in the crontab pings a private URL when the job starts and when it ends. If a ping doesn’t arrive within the schedule plus your grace window, the job fails, or a run hangs, the team gets a normal alert. Jobs with no schedule, like queue workers, use an on-demand Heartbeat instead.

What happens if a channel is down?

Email retries up to three times with exponential backoff, and a delivery that still fails is marked as failed. A broken Slack or Microsoft Teams channel never blocks the email, and in-app always lands.

Make the alert channel worth reading again

One API key, one POST.

Start free Read the docs