Мониторинг здоровья email через публичный API Nova Uptime: гайд для разработчиков

Зачем использовать API Nova Uptime для мониторинга здоровья email#

Если вы управляете клиентскими доменами (SaaS-платформа, хостинг-провайдер, агентство), вам нужно программно проверять здоровье email по всем доменам сразу.

Три подхода:

1. Вручную: проверять каждый домен в дашборде Nova Uptime. Не масштабируется.
2. WHOIS-запросы: писать кастомный парсинг DKIM/SPF/DMARC. Сложно, ненадёжно.
3. Публичный API Nova Uptime: REST API, обрабатывающий всю сложность. Масштабируемо, надёжно, поддерживается.

Это руководство — про API-подход.

Обзор API#

Base URL: https://api.novauptime.com/api/v1

Аутентификация: заголовок X-API-Key

Rate-лимиты: 50 запросов/час на бесплатном тарифе, 1 000/час на платном

Формат ответа:

{
  "success": true,
  "data": { ... },
  "message": "Optional message"
}

Шаг 1: сгенерируйте API-ключ#

1. Войдите на go.novauptime.com
2. Settings → API Keys
3. Нажмите «Generate New Key»
4. Скопируйте 20-символьный ключ (например, abc123def456ghi789jk)
5. Храните безопасно (не коммитьте в git!)

Переменная окружения:

export NOVAUPTIME_API_KEY="abc123def456ghi789jk"

Шаг 2: проверьте здоровье email домена#

Эндпоинт: GET /domains/{domain}/email-health

Пример запроса:

curl -H "X-API-Key: abc123def456ghi789jk" \
  https://api.novauptime.com/api/v1/domains/example.com/email-health

Ответ:

{
  "success": true,
  "data": {
    "domain": "example.com",
    "score": 92,
    "grade": "A",
    "timestamp": "2026-02-20T10:30:00Z",
    "records": {
      "mx": {
        "status": "configured",
        "value": "mail.example.com"
      },
      "spf": {
        "status": "configured",
        "value": "v=spf1 include:sendgrid.net -all",
        "lookups": 4
      },
      "dkim": {
        "status": "configured",
        "selectors": ["s1", "s2"],
        "configured_count": 2
      },
      "dmarc": {
        "status": "configured",
        "policy": "reject"
      },
      "blacklist": {
        "status": "clean",
        "checked_against": 4,
        "listed_on": 0
      }
    },
    "recommendations": [
      {
        "type": "warning",
        "message": "SPF record has 4 lookups (limit is 10). Consider consolidating includes.",
        "action": "Use SPF flattening service or consolidate email providers"
      }
    ]
  }
}

Реальные кейсы

Кейс 1: дашборд агентства#

Вы — агентство, управляющее 100+ клиентскими сайтами. Хотите показывать каждому клиенту здоровье его email в дашборде.

Реализация:

// Express.js маршрут для получения здоровья email
app.get("/client/:clientId/email-health", async (req, res) => {
  const clientId = req.params.clientId;

  // Получить домен клиента из БД
  const client = await Client.findById(clientId);
  const domain = client.primaryDomain;

  // Запросить здоровье email у Nova Uptime
  const response = await fetch(
    `https://api.novauptime.com/api/v1/domains/${domain}/email-health`,
    {
      headers: { "X-API-Key": process.env.NOVAUPTIME_API_KEY }
    }
  );

  const emailHealth = await response.json();

  // Вернуть на фронт
  res.json(emailHealth.data);
});

Кейс 2: автоматизированная оценка здоровья email#

Оценивайте все клиентские домены и алертите при деградации.

Реализация:

// Cron-задача: ежедневная проверка всех доменов
async function dailyEmailHealthAudit() {
  const domains = await Domain.find();

  for (const domain of domains) {
    // Получить текущий балл
    const current = await fetchEmailHealth(domain.name);

    // Сравнить с предыдущим днём
    const previous = await EmailHealthHistory.findLatest(domain.name);

    if (current.data.score < previous.score - 5) {
      // Балл упал >5 пунктов — алерт
      await sendSlackAlert({
        domain: domain.name,
        oldScore: previous.score,
        newScore: current.data.score,
        change: current.data.score - previous.score
      });
    }

    // Сохранить историю
    await EmailHealthHistory.create({
      domain: domain.name,
      score: current.data.score,
      timestamp: new Date()
    });
  }
}

Кейс 3: массовый аудит доменов#

Вы купили конкурента. 50 новых клиентских доменов. Хотите статус здоровья email для всех.

Реализация:

// Получить здоровье email для 50 доменов
async function auditAcquiredDomains(acquiredDomains) {
  const results = [];

  // Запросы с лимитом параллелизма (5 одновременно)
  for (const domain of acquiredDomains) {
    const health = await fetchEmailHealth(domain);
    results.push({
      domain,
      score: health.data.score,
      grade: health.data.grade,
      issues: health.data.recommendations
    });
  }

  // Экспорт в CSV
  const csv = convertToCSV(results);
  fs.writeFileSync("email-health-audit.csv", csv);

  // Сводка: 40 доменов здоровы, 10 нужно чинить
  console.log(`Healthy: ${results.filter(r => r.score > 80).length}`);
  console.log(`Need fixes: ${results.filter(r => r.score < 80).length}`);
}

API-паттерны для продакшна#

Паттерн 1: кэширование с истечением#

Не вызывайте API при каждом запросе. Кэшируйте локально.

const redis = require("redis");
const client = redis.createClient();

async function getEmailHealthCached(domain, maxAge = 3600) {
  // Сначала пробуем кэш
  const cached = await client.get(`email-health:${domain}`);
  if (cached) {
    return JSON.parse(cached);
  }

  // Кэш-мисс — запрашиваем у API
  const health = await fetchEmailHealth(domain);

  // Кладём в кэш на 1 час
  await client.setex(
    `email-health:${domain}`,
    maxAge,
    JSON.stringify(health.data)
  );

  return health.data;
}

Паттерн 2: обработка rate-лимитов#

У API Nova Uptime есть rate-лимиты. Обрабатывайте корректно.

async function fetchWithRetry(domain, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(
        `https://api.novauptime.com/api/v1/domains/${domain}/email-health`,
        {
          headers: { "X-API-Key": process.env.NOVAUPTIME_API_KEY },
          timeout: 10000
        }
      );

      if (response.status === 429) {
        // Rate-limit — ждём перед повтором
        const retryAfter = response.headers.get("Retry-After") || (2 ** i);
        console.log(`Rate limited. Retrying in ${retryAfter}s`);
        await new Promise(r => setTimeout(r, retryAfter * 1000));
        continue;
      }

      if (!response.ok) throw new Error(`HTTP ${response.status}`);

      return await response.json();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      console.log(`Attempt ${i + 1} failed, retrying...`);
      await new Promise(r => setTimeout(r, (2 ** i) * 1000));
    }
  }
}

Паттерн 3: пакетная обработка#

При проверке 100+ доменов эффективно батчите запросы.

async function batchEmailHealthCheck(domains) {
  const batchSize = 10; // 10 параллельных запросов
  const results = [];

  for (let i = 0; i < domains.length; i += batchSize) {
    const batch = domains.slice(i, i + batchSize);

    // Параллельная обработка батча
    const batchResults = await Promise.all(
      batch.map(domain => fetchEmailHealth(domain))
    );

    results.push(...batchResults);

    // Лог прогресса
    console.log(`Processed ${Math.min(i + batchSize, domains.length)}/${domains.length}`);
  }

  return results;
}

Паттерн 4: локальное хранение результатов#

Храните результаты здоровья email в собственной БД для исторического отслеживания.

// Модель БД
const EmailHealthSchema = {
  domain: String,
  score: Number,
  grade: String,
  records: {
    mx: Object,
    spf: Object,
    dkim: Object,
    dmarc: Object,
    blacklist: Object
  },
  timestamp: Date,
  createdAt: Date
};

async function storeEmailHealth(domain) {
  const health = await fetchEmailHealth(domain);

  // Сохранение в БД
  const record = new EmailHealthLog({
    domain,
    score: health.data.score,
    grade: health.data.grade,
    records: health.data.records,
    timestamp: new Date(health.data.timestamp),
    createdAt: new Date()
  });

  await record.save();

  return record;
}

Паттерн 5: алертинг на изменения#

Отслеживайте изменения и алертите команду, когда что-то ломается.

async function monitorEmailHealth(domain) {
  const current = await getEmailHealthCached(domain);
  const previous = await EmailHealthLog.findLatest(domain);

  if (!previous) {
    // Первая проверка — просто сохраняем
    await storeEmailHealth(domain);
    return;
  }

  // Обнаружение изменений
  const scoreChange = current.score - previous.score;

  if (scoreChange < -10) {
    // Серьёзная деградация
    await alertSlack({
      channel: "#email-alerts",
      message: `
        ${domain}: Email health degraded
        Previous: ${previous.score} (${previous.grade})
        Current: ${current.score} (${current.grade})
        Change: ${scoreChange < 0 ? "" : "+"}${scoreChange}

        Issues: ${current.recommendations.map(r => r.message).join("\n")}
      `
    });
  }
}

Обработка ошибок

Типичные сценарии ошибок:

async function robustEmailHealthCheck(domain) {
  try {
    const health = await fetchWithRetry(domain);
    return health.data;
  } catch (error) {
    if (error.code === "ENOTFOUND") {
      // Домен не существует
      console.error(`Domain ${domain} not found`);
      return null;
    } else if (error.statusCode === 401) {
      // Невалидный API-ключ
      console.error("Invalid Nova Uptime API key");
      return null;
    } else if (error.statusCode === 429) {
      // Rate-limit (даже после повторов)
      console.error("Rate limit exceeded");
      return null;
    } else {
      // Неизвестная ошибка
      console.error(`Error checking ${domain}: ${error.message}`);
      return null;
    }
  }
}

Интеграция с фронтендом

Пример React-компонента#

import { useState, useEffect } from 'react';

function EmailHealthCard({ domain }) {
  const [health, setHealth] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function fetchHealth() {
      try {
        const response = await fetch(`/api/email-health/${domain}`);
        const data = await response.json();
        setHealth(data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchHealth();
  }, [domain]);

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;

  return (
    <div className="email-health-card">
      <h3>{domain}</h3>
      <div className={`score score-${health.grade}`}>
        {health.score}/100 ({health.grade})
      </div>

      <div className="records">
        {Object.entries(health.records).map(([key, value]) => (
          <div key={key} className={`record ${value.status}`}>
            <strong>{key.toUpperCase()}</strong>: {value.status}
          </div>
        ))}
      </div>

      {health.recommendations.length > 0 && (
        <div className="recommendations">
          <h4>Recommendations:</h4>
          <ul>
            {health.recommendations.map((rec, i) => (
              <li key={i} className={rec.type}>
                {rec.message}
              </li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
}

Справочник по API#

Base URL: https://api.novauptime.com/api/v1

Эндпоинты:

GET /domains/{domain}/email-health
  → Проверить здоровье email домена
  → Rate-лимит: 50/час (free), 1000/час (paid)
  → Ответ: балл здоровья email, оценка, записи, рекомендации

GET /domains/{domain}/incidents
  → Получить последние 20 инцидентов простоя
  → Опциональные параметры: limit, offset

GET /domains/{domain}/history
  → Получить историю проверок (настраиваемые часы, макс 720h)
  → Опциональные параметры: hours (по умолч. 168), limit (по умолч. 500)

GET /domains
  → Список доменов пользователя (с пагинацией, макс 50/стр)
  → Опциональные параметры: page, limit

Лучшие практики

1. Кэшируйте агрессивно: здоровье email меняется нечасто. Кэшируйте на 1–24 часа.
2. Батчите запросы: проверяйте 10 доменов параллельно, а не по одному.
3. Обрабатывайте ошибки корректно: сетевые проблемы случаются. Повторяйте с экспоненциальным backoff.
4. Мониторьте API: отслеживайте использование. При приближении к rate-лимиту — кэшируйте дольше.
5. Защищайте API-ключ: никогда не коммитьте в git. Используйте переменные окружения.
6. Тестируйте rate-лимиты: симулируйте высокий объём перед деплоем в продакшн.

Итог: чек-лист интеграции API#

• ✅ Сгенерировать и защитить API-ключ
• ✅ Реализовать базовую проверку здоровья email
• ✅ Добавить слой кэширования (Redis или in-memory)
• ✅ Реализовать обработку rate-лимитов
• ✅ Добавить обработку типичных ошибок
• ✅ Протестировать на реальном домене
• ✅ Построить фронтенд-компонент для отображения результатов
• ✅ Настроить алертинг на изменения балла
• ✅ Задокументировать управление API-ключами в командной wiki
• ✅ Мониторить использование и квоту API

Начните сегодня

Публичный API Nova Uptime доступен на бесплатном тарифе. Сгенерируйте первый API-ключ в Settings и начните интегрировать проверки здоровья email в свою платформу.

Подробный справочник по API — в документации Nova Uptime API.