Документация API

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  -H "Content-Type: application/json" \
  -d '{"title": "Сервер упал", "body": "Проверьте прод", "priority": "high"}'

{
  "notificationId": "b3f1c0de-4b1a-4c9b-9f3d-5a6b7c8d9e01",
  "queued": 2,
  "channels": ["WebPush", "Email"],
  "deduplicated": false,
  "replayed": false,
  "warning": null,
  "devicesNotified": 1
}

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" -d "title=Проверка связи"

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "Authorization: Bearer fa_ваш_ключ" -d "title=Проверка связи"

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  -H "Content-Type: application/json" \
  -d '{
        "group": "prod-db",
        "title": "Реплика отстала на 240 секунд",
        "body": "pg-replica-2, lag растёт последние 10 минут.",
        "priority": "high",
        "dedupKey": "replication-lag:pg-replica-2",
        "dedupWindowSeconds": 1800,
        "url": "https://grafana.example.com/d/pg/replication"
      }'

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  -F "group=prod-api" \
  -F "title=Деплой откатился" \
  -F "body=Health-check не прошёл на 3 узлах из 4." \
  -F "priority=critical" \
  -F "log=@/var/log/deploy.log"

df -h / | curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  -H "Content-Type: text/plain" \
  --data-binary @-

curl -G https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  --data-urlencode "title=Бэкап завершён" \
  --data-urlencode "body=42 ГБ за 18 минут" \
  --data-urlencode "group=prod-db" \
  --data-urlencode "priority=low"

curl -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: fa_ваш_ключ" \
  -H "Idempotency-Key: deploy-2026-08-04-a1b2c3d" \
  -H "Content-Type: application/json" \
  -d '{"title": "Деплой 2026.8.4 завершён", "priority": "low"}'

{
  "error": "title_required",
  "detail": "Укажите заголовок уведомления в поле title."
}

curl -fsS -m 5 -o /dev/null https://api.example.com/health || \
curl -fsS -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: $ACE_KEY" \
  -F "group=prod-api" \
  -F "title=api.example.com не отвечает" \
  -F "body=/health не отдал 200 за 5 секунд." \
  -F "priority=high" \
  -F "dedupKey=health:api.example.com" \
  -F "dedupWindowSeconds=1800" >/dev/null

{
  "notificationId": "b3f1c0de-4b1a-4c9b-9f3d-5a6b7c8d9e01",
  "queued": 0,
  "channels": [],
  "deduplicated": true,
  "replayed": false,
  "devicesNotified": 0
}

{ "status": "ok", "monitor": "Ночной бэкап", "receivedAt": "2026-08-04T02:31:07.412Z" }

# Пинг только если бэкап отработал без ошибки.
0 3 * * * /usr/local/bin/backup.sh && curl -fsS -m 10 -o /dev/null https://fastalert.ru/ping/ВАШ_ТОКЕН

# Или просто «сервер жив», раз в 5 минут.
*/5 * * * * curl -fsS -m 10 -o /dev/null https://fastalert.ru/ping/ВАШ_ТОКЕН

[Unit]
Description=Heartbeat в FastAlert

[Service]
Type=oneshot
ExecStart=/usr/bin/curl -fsS -m 10 -o /dev/null https://fastalert.ru/ping/ВАШ_ТОКЕН

[Unit]
Description=Heartbeat в FastAlert каждые 5 минут

[Timer]
OnBootSec=2min
OnUnitActiveSec=5min
AccuracySec=15s

[Install]
WantedBy=timers.target

systemctl daemon-reload
systemctl enable --now ace-heartbeat.timer

HEALTHCHECK --interval=60s --timeout=5s --start-period=20s --retries=3 \
  CMD curl -fsS -m 3 http://localhost:8080/health \
      && curl -fsS -m 5 -o /dev/null https://fastalert.ru/ping/ВАШ_ТОКЕН \
      || exit 1

      - name: Heartbeat
        if: success()
        run: curl -fsS -m 10 -o /dev/null "$ACE_PING_URL"
        env:
          ACE_PING_URL: ${{ secrets.ACE_PING_URL }}

{
  "acknowledged": true,
  "alreadyAcknowledged": false,
  "acknowledgedAt": "2026-08-04T03:04:11.882Z"
}

{
  "id": "b3f1c0de-4b1a-4c9b-9f3d-5a6b7c8d9e01",
  "title": "Реплика отстала на 240 секунд",
  "body": "pg-replica-2, lag растёт последние 10 минут.",
  "priority": "high",
  "group": "Прод / БД",
  "createdAt": "2026-08-04T03:01:44.1180000+00:00",
  "url": "https://grafana.example.com/d/pg/replication",
  "ackUrl": "https://fastalert.ru/ack/9dQ2…",
  "attachments": 0,
  "data": {
    "notificationId": "b3f1c0de-4b1a-4c9b-9f3d-5a6b7c8d9e01",
    "groupId": "0f2b1a77-9c3e-4d21-8b60-1e5f7a2c4d90",
    "priority": "high",
    "source": "api",
    "dedupKey": "replication-lag:pg-replica-2"
  }
}

import hashlib
import hmac
import os
import time

from flask import Flask, request, abort

SECRET = os.environ["ACE_WEBHOOK_SECRET"].encode()
MAX_SKEW_SECONDS = 300

app = Flask(__name__)


@app.post("/ace-webhook")
def fastalert_webhook():
    raw = request.get_data()  # сырые байты, до разбора JSON
    ts = request.headers.get("X-FastAlert-Timestamp", "")
    signature = request.headers.get("X-FastAlert-Signature", "")

    if not ts.isdigit() or abs(time.time() - int(ts)) > MAX_SKEW_SECONDS:
        abort(400)  # слишком старый запрос — возможен повтор перехваченного

    expected = "sha256=" + hmac.new(
        SECRET, ts.encode() + b"." + raw, hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        abort(401)

    event = request.get_json()
    app.logger.warning("%s: %s", event["priority"], event["title"])
    return "", 200

const crypto = require("node:crypto");
const express = require("express");

const SECRET = process.env.ACE_WEBHOOK_SECRET;
const MAX_SKEW_SECONDS = 300;

const app = express();

// express.raw обязателен: подпись считается по телу до разбора JSON.
app.post("/ace-webhook", express.raw({ type: "application/json" }), (req, res) => {
  const ts = req.get("X-FastAlert-Timestamp") || "";
  const signature = req.get("X-FastAlert-Signature") || "";

  if (!/^\d+$/.test(ts) || Math.abs(Date.now() / 1000 - Number(ts)) > MAX_SKEW_SECONDS) {
    return res.sendStatus(400);
  }

  const expected = "sha256=" + crypto
    .createHmac("sha256", SECRET)
    .update(Buffer.concat([Buffer.from(`${ts}.`, "utf8"), req.body]))
    .digest("hex");

  const a = Buffer.from(expected, "utf8");
  const b = Buffer.from(signature, "utf8");
  // timingSafeEqual бросает исключение на разной длине — длину проверяем заранее.
  if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
    return res.sendStatus(401);
  }

  const event = JSON.parse(req.body.toString("utf8"));
  process.stdout.write(`${event.priority}: ${event.title}\n`);
  res.sendStatus(200);
});

app.listen(3000);

export ACE_KEY="fa_ваш_ключ"

# ace "Заголовок" ["Текст"] ["приоритет"]
ace() {
  curl -fsS -X POST https://fastalert.ru/api/v1/notify \
    -H "X-Api-Key: $ACE_KEY" \
    -F "title=$1" \
    -F "body=${2:-}" \
    -F "priority=${3:-normal}" >/dev/null
}

# Длинная команда, уведомление по завершении:
#   make deploy; ace "Деплой закончился (код $?)"

#!/bin/sh
# Обёртка для cron-задачи: при успехе молчит, при падении шлёт алерт с логом.
set -u

LOG=$(mktemp)
"$@" >"$LOG" 2>&1
CODE=$?

if [ "$CODE" -eq 0 ]; then
  rm -f "$LOG"
  exit 0
fi

curl -fsS -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: $ACE_KEY" \
  -F "title=$(hostname): $1 завершилась с кодом $CODE" \
  -F "body=<$LOG" \
  -F "priority=high" \
  -F "dedupKey=cron:$(hostname):$1" \
  -F "log=@$LOG" >/dev/null

rm -f "$LOG"
exit "$CODE"

ACE_KEY=fa_ваш_ключ
30 3 * * * root /usr/local/bin/run-or-alert /usr/local/bin/backup.sh

[Unit]
Description=Обработчик очереди
OnFailure=ace-alert@%n.service

[Unit]
Description=Алерт в FastAlert о падении %i

[Service]
Type=oneshot
EnvironmentFile=/etc/acenotifier.env
ExecStart=/usr/local/bin/ace-unit-alert %i

#!/bin/sh
# Аргумент — полное имя упавшего юнита (systemd подставит его через %n).
set -eu

journalctl -u "$1" -n 50 --no-pager | curl -fsS -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: $ACE_KEY" \
  -F "title=$(hostname): юнит $1 упал" \
  -F "body=<-" \
  -F "priority=high" \
  -F "dedupKey=systemd:$(hostname):$1" >/dev/null

#!/bin/sh
set -eu
ACE_KEY="fa_ваш_ключ"

curl -fsS -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: $ACE_KEY" \
  -F "group=$1" \
  -F "title=$2" \
  -F "body=$3" \
  -F "priority=high" \
  -F "dedupKey=zabbix:$2" >/dev/null

receivers:
  - name: acenotifier
    webhook_configs:
      - url: http://127.0.0.1:9099/alertmanager
        send_resolved: true

import os

import requests
from flask import Flask, request

ACE = "https://fastalert.ru/api/v1/notify"
KEY = os.environ["ACE_KEY"]

app = Flask(__name__)
session = requests.Session()
session.headers["X-Api-Key"] = KEY


@app.post("/alertmanager")
def relay():
    payload = request.get_json(silent=True) or {}
    resolved = payload.get("status") == "resolved"

    for alert in payload.get("alerts", []):
        labels = alert.get("labels", {})
        annotations = alert.get("annotations", {})
        name = labels.get("alertname", "Alertmanager")

        session.post(
            ACE,
            json={
                "group": labels.get("group", "prod"),
                "title": ("Закрыт: " if resolved else "") + name,
                "body": annotations.get("description") or annotations.get("summary", ""),
                "priority": "low" if resolved else "high",
                "dedupKey": f"am:{name}:{labels.get('instance', '-')}",
                "dedupWindowSeconds": 1800,
                "url": alert.get("generatorURL"),
            },
            timeout=10,
        )

    return "", 204

{
  "group": "prod-web",
  "title": "{{ monitor.name }}",
  "body": "{{ msg }}",
  "priority": "high",
  "dedupKey": "kuma:{{ monitor.name }}",
  "dedupWindowSeconds": 1800
}

      - name: Уведомить о падении сборки
        if: failure()
        env:
          ACE_KEY: ${{ secrets.ACE_KEY }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref_name }}
          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
        run: |
          curl -fsS -X POST https://fastalert.ru/api/v1/notify \
            -H "X-Api-Key: $ACE_KEY" \
            -F "title=CI упал: $REPO" \
            -F "body=Ветка $BRANCH, запуск $RUN_URL" \
            -F "priority=high" \
            -F "url=$RUN_URL" \
            -F "dedupKey=ci:$REPO:$BRANCH"

import logging

import requests


class AceHandler(logging.Handler):
    """Отправляет записи уровня ERROR и выше в FastAlert."""

    def __init__(self, api_key, base_url="https://fastalert.ru", group=None, timeout=5):
        super().__init__(level=logging.ERROR)
        self.url = base_url.rstrip("/") + "/api/v1/notify"
        self.group = group
        self.timeout = timeout
        self.session = requests.Session()
        self.session.headers["X-Api-Key"] = api_key

    def emit(self, record):
        try:
            payload = {
                "title": f"{record.levelname} {record.name}: {record.getMessage()}"[:200],
                "body": self.format(record)[:8000],
                "priority": "critical" if record.levelno >= logging.CRITICAL else "high",
                # Один и тот же кадр стека не должен будить всю ночь.
                "dedupKey": f"log:{record.name}:{record.module}:{record.lineno}",
                "dedupWindowSeconds": 900,
            }
            if self.group:
                payload["group"] = self.group
            self.session.post(self.url, json=payload, timeout=self.timeout)
        except Exception:
            self.handleError(record)


logger = logging.getLogger("app")
handler = AceHandler(api_key="fa_ваш_ключ", group="prod-api")
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s\n%(message)s"))
logger.addHandler(handler)

{
  "error": "quota_exceeded",
  "detail": "Исчерпан месячный лимит тарифа «Старт»: 1000 уведомлений. Лимит обновится 1-го числа."
}

import os

import requests

response = requests.post(
    "https://fastalert.ru/api/v1/notify",
    headers={
        "X-Api-Key": os.environ["ACE_KEY"],
        "Idempotency-Key": "backup-2026-08-04",
    },
    json={
        "group": "prod-db",
        "title": "Бэкап не удался",
        "body": "pg_dump вернул код 1: could not connect to server",
        "priority": "high",
        "dedupKey": "backup:prod-db",
        "dedupWindowSeconds": 3600,
    },
    timeout=10,
)
response.raise_for_status()
notification_id = response.json()["notificationId"]

const response = await fetch("https://fastalert.ru/api/v1/notify", {
  method: "POST",
  headers: {
    "X-Api-Key": process.env.ACE_KEY,
    "Content-Type": "application/json",
    "Idempotency-Key": `deploy-${process.env.GITHUB_SHA ?? Date.now()}`,
  },
  body: JSON.stringify({
    group: "prod-api",
    title: "Деплой завершён",
    body: "Версия 2026.8.4 выкачена на 4 узла.",
    priority: "low",
  }),
});

if (response.status !== 202) {
  const { error, detail } = await response.json();
  throw new Error(`FastAlert: ${error}${detail ? " — " + detail : ""}`);
}

package acenotifier

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type Notification struct {
	Group    string `json:"group,omitempty"`
	Title    string `json:"title"`
	Body     string `json:"body,omitempty"`
	Priority string `json:"priority,omitempty"`
	DedupKey string `json:"dedupKey,omitempty"`
}

var client = &http.Client{Timeout: 10 * time.Second}

func Notify(apiKey string, n Notification) error {
	raw, err := json.Marshal(n)
	if err != nil {
		return err
	}

	req, err := http.NewRequest(http.MethodPost,
		"https://fastalert.ru/api/v1/notify", bytes.NewReader(raw))
	if err != nil {
		return err
	}
	req.Header.Set("X-Api-Key", apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusAccepted {
		return fmt.Errorf("acenotifier: HTTP %d", resp.StatusCode)
	}
	return nil
}

<?php

function fastalert_notify(string $apiKey, array $payload): void
{
    $ch = curl_init('https://fastalert.ru/api/v1/notify');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode($payload, JSON_UNESCAPED_UNICODE),
        CURLOPT_HTTPHEADER     => ['X-Api-Key: ' . $apiKey, 'Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 10,
    ]);

    $body = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($code !== 202) {
        throw new RuntimeException("FastAlert: HTTP $code $body");
    }
}

fastalert_notify(getenv('ACE_KEY'), [
    'group'    => 'prod-api',
    'title'    => 'Очередь не разбирается',
    'body'     => 'В очереди 12 400 задач, воркеры простаивают.',
    'priority' => 'high',
    'dedupKey' => 'queue-stuck:prod-api',
]);

using System.Net;
using System.Net.Http.Json;

using var http = new HttpClient { BaseAddress = new Uri("https://fastalert.ru") };
http.DefaultRequestHeaders.Add("X-Api-Key", Environment.GetEnvironmentVariable("ACE_KEY"));

var response = await http.PostAsJsonAsync("/api/v1/notify", new
{
    group = "prod-api",
    title = "Миграция не применилась",
    body = "relation \"orders\" does not exist",
    priority = "critical",
    dedupKey = "migrate:orders",
});

if (response.StatusCode != HttpStatusCode.Accepted)
{
    throw new InvalidOperationException(
        $"FastAlert: HTTP {(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");
}

#!/bin/sh
set -eu

curl -fsS -X POST https://fastalert.ru/api/v1/notify \
  -H "X-Api-Key: $ACE_KEY" \
  -F "group=prod-api" \
  -F "title=$(hostname): свободно менее 5% диска" \
  -F "body=$(df -h / | tail -n 1)" \
  -F "priority=high" \
  -F "dedupKey=disk:$(hostname):/" \
  -F "dedupWindowSeconds=3600" >/dev/null

$body = @{
    group    = 'prod-win'
    title    = "$env:COMPUTERNAME: служба остановлена"
    body     = 'W3SVC не поднялась после перезапуска.'
    priority = 'high'
    dedupKey = "service:$env:COMPUTERNAME:W3SVC"
} | ConvertTo-Json

# Windows PowerShell 5.1 отправляет строку в кодировке по умолчанию,
# поэтому кириллицу передаём готовыми UTF-8 байтами.
Invoke-RestMethod -Method Post `
    -Uri 'https://fastalert.ru/api/v1/notify' `
    -Headers @{ 'X-Api-Key' = $env:ACE_KEY } `
    -ContentType 'application/json; charset=utf-8' `
    -Body ([Text.Encoding]::UTF8.GetBytes($body))