tutorial

Uptime Monitoring for Docusaurus Documentation Sites 2026

Docusaurus builds your docs but won't alert you when they go offline. Add health endpoints, deploy heartbeats, and external uptime monitoring in under 30 minutes — free.

Uptime Monitoring for Docusaurus Documentation Sites 2026

Docusaurus is the go-to static site generator for open-source and developer documentation. Your team writes MDX, customizes themes, and ships polished docs sites. But Docusaurus's job is to build and render your docs — it doesn't monitor whether they're accessible to your users.

By the end of this guide you'll have external uptime monitoring on your Docusaurus deployment, heartbeat monitoring for your build pipeline, and instant alerts when your docs go offline — all on the free tier.

The gap Docusaurus doesn't cover

Docusaurus is a build tool. It produces a static site that you host somewhere — Netlify, Vercel, GitHub Pages, a CDN, or your own server. That hosting layer can fail silently.

What can go wrong after a successful build:

  • CDN edge node goes down — docs 404 in one region
  • Deployment succeeds but the new build is broken (bad plugin, broken import)
  • GitHub Pages quota hit or custom domain SSL cert expires
  • Self-hosted Nginx restarts and misconfigures the root
  • Vercel or Netlify has a platform incident

Docusaurus won't tell you about any of these. Your users will.

Step 1: Identify your monitoring target

Docusaurus outputs a static bundle. There's no app server — your monitoring target is the web host serving that bundle.

Pick the URL that represents your live docs:

| Hosting | Typical URL pattern | |---|---| | GitHub Pages | https://<org>.github.io/<repo>/ | | Netlify | https://your-project.netlify.app or custom domain | | Vercel | https://your-project.vercel.app or custom domain | | Self-hosted | https://docs.yourdomain.com |

If you have a custom domain, monitor that — not the platform subdomain. DNS misconfiguration and certificate issues will hit the custom domain first.

Step 2: Set up external HTTP monitoring with Vigilmon

Sign up at Vigilmon — free tier, no credit card required.

  1. Click New Monitor → HTTP
  2. Enter your docs URL (e.g. https://docs.yourdomain.com)
  3. Set check interval to 5 minutes
  4. Under Expected status code, keep 200
  5. Optionally add a Keyword match on a string that must appear in the response body (e.g. your site title or a nav item)
  6. Save

The keyword match is powerful for Docusaurus: a CDN misconfiguration can serve a 200 with an Nginx default page instead of your docs. Matching on a known string in your docs content catches that false positive.

Recommended monitors for a Docusaurus site:

| Monitor | URL | What it catches | |---|---|---| | Homepage | https://docs.yourdomain.com | Total outage | | A deep doc page | https://docs.yourdomain.com/getting-started | Routing or build errors | | Search endpoint (if using Algolia) | https://your-index.algolia.net | Broken search UX |

Step 3: Add a heartbeat monitor to your build pipeline

When your Docusaurus build pipeline stops running — a broken GitHub Action, a Netlify build failing silently, a cron misconfiguration — your docs go stale. Users see outdated content. No one notices.

The heartbeat pattern: ping a unique Vigilmon URL after each successful build. If the ping doesn't arrive in the expected window, Vigilmon fires an alert.

In Vigilmon:

  1. Click New Monitor → Heartbeat
  2. Set the expected interval to match your build cadence (e.g. 25 hours for a daily build — add a buffer)
  3. Copy the ping URL

GitHub Actions (most common Docusaurus setup):

# .github/workflows/deploy-docs.yml
name: Deploy Docs

on:
  push:
    branches: [main]
  schedule:
    - cron: '0 4 * * *'  # Nightly rebuild for freshness

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Build Docusaurus
        run: npm run build

      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./build

      - name: Ping heartbeat on success
        if: success()
        run: curl -s "${{ secrets.DOCS_BUILD_HEARTBEAT_URL }}"

Netlify (via netlify.toml):

Netlify doesn't support post-deploy shell commands natively in netlify.toml, but you can use a build plugin:

// plugins/heartbeat/index.js
module.exports = {
  onSuccess: async ({ utils }) => {
    const url = process.env.DOCS_BUILD_HEARTBEAT_URL;
    if (!url) return;
    try {
      await fetch(url);
      console.log('Heartbeat pinged.');
    } catch (err) {
      console.error('Heartbeat ping failed:', err.message);
    }
  },
};

# netlify.toml
[[plugins]]
  package = "./plugins/heartbeat"

Add DOCS_BUILD_HEARTBEAT_URL to your Netlify environment variables (Site settings → Environment variables).

Step 4: Monitor your search infrastructure

Most serious Docusaurus sites use Algolia DocSearch for full-text search. If Algolia goes down or your index stops updating, your search silently breaks while the rest of the docs appear fine.

Add an Algolia health check:

// scripts/check-algolia.mjs
import algoliasearch from 'algoliasearch';

const client = algoliasearch(
  process.env.ALGOLIA_APP_ID,
  process.env.ALGOLIA_SEARCH_KEY
);

async function checkAlgolia() {
  try {
    const index = client.initIndex(process.env.ALGOLIA_INDEX_NAME);
    const { nbHits } = await index.search('', { hitsPerPage: 0 });
    if (nbHits === 0) {
      console.error('Algolia index is empty');
      process.exit(1);
    }
    console.log(`Algolia OK: ${nbHits} records indexed`);
  } catch (err) {
    console.error('Algolia check failed:', err.message);
    process.exit(1);
  }
}

checkAlgolia();

Run this as part of your CI pipeline and add a separate heartbeat monitor for Algolia index health. Zero records or a thrown error means the search index needs attention before users notice.

Step 5: SSL certificate monitoring

Docusaurus sites almost always use HTTPS. A lapsed certificate is a hard outage — browsers block access entirely.

Vigilmon automatically checks the SSL certificate expiry for every HTTPS monitor. You'll receive an alert before the certificate expires, not after.

For custom domains:

  1. Your monitor is already watching the SSL cert as part of the HTTP check
  2. Vigilmon will alert you 30 days, 14 days, and 7 days before expiry by default

If you use Cloudflare or a CDN that handles SSL termination, make sure your origin certificate (between Cloudflare and your server) is also valid — Cloudflare can serve cached content over a broken origin cert for a while, masking the issue.

Step 6: Webhook alerts to Slack or Discord

Docs teams usually live in Slack or Discord. Route alerts there:

Slack:

  1. Create an incoming webhook in your workspace
  2. In Vigilmon go to Notifications → New Channel → Slack
  3. Paste the webhook URL and enable it on your monitors

Discord:

  1. Server Settings → Integrations → Webhooks → New Webhook
  2. Copy the URL
  3. In Vigilmon go to Notifications → New Channel → Discord
  4. Paste and enable

Route alerts to the same channel where your CI build notifications go — your team sees a broken build and a monitoring alert in context.

Step 7: Public status page

When your docs site is down during an incident, a status page lets users self-serve status rather than opening issues or asking in Discord.

  1. Go to Status Pages → New Status Page
  2. Name it (e.g. "Acme Docs Status")
  3. Select your Docusaurus monitors
  4. Save and link from your docs footer

Add the status page link to your docusaurus.config.js footer:

// docusaurus.config.js
module.exports = {
  // ...
  themeConfig: {
    footer: {
      links: [
        {
          title: 'More',
          items: [
            {
              label: 'Status',
              href: 'https://status.yourdomain.com',
            },
          ],
        },
      ],
    },
  },
};

What you've built

| What | How | |---|---| | External uptime monitoring | Vigilmon HTTP monitors on homepage + deep pages | | Build pipeline heartbeat | Ping on successful deploy; missed ping triggers alert | | Search health check | Algolia index record count check in CI | | SSL certificate monitoring | Automatic via Vigilmon HTTP monitors | | Instant alerts | Slack/Discord webhook notifications | | Public status page | Vigilmon status page linked from docs footer |

Docusaurus builds your docs. Vigilmon ensures they're always reachable. Together you have complete coverage — build correctness and continuous availability.

Get started free at vigilmon.online — your first monitor is running in under a minute.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles