Media Luna Documentation

Media Luna is a multi-region uptime monitoring platform that gives you real-time visibility into the health and performance of your websites, APIs, servers, and infrastructure. With distributed probes across the globe, you get accurate, location-aware monitoring with instant incident detection and flexible alerting.

Key Features

Quick Start

Get up and running with Media Luna in under 5 minutes.

Step 1 — Create an account

1. Go to monitor.media-luna.co/register
2. Enter your email and password
3. Verify your email address

Step 2 — Create your first monitor

1. Click Add Monitor from the dashboard
2. Enter your website URL
3. Select HTTP as the monitor type
4. Set check interval to 1 minute
5. Click Create Monitor

Step 3 — Set up notifications

1. Go to Notification Channels and verify your email is listed
2. Go to Notification Rules → Create Rule
3. Select your monitor and choose when to notify
4. Pick notification channels and save

Using the API instead?

# Store your API key securely
export MEDIALUNA_API_KEY="sk_live_your_key_here"

# Create a monitor
curl -X POST https://api.media-luna.co/api/v1/monitors \
  -H "Authorization: Bearer $MEDIALUNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Website",
    "type": "HTTP",
    "url": "https://yoursite.com",
    "check_interval": 60
  }'

# Verify it's working
curl https://api.media-luna.co/api/v1/monitors \
  -H "Authorization: Bearer $MEDIALUNA_API_KEY"

Your monitor will start receiving checks within 60 seconds from the assigned probe region. The status will transition from pending to up once the first successful check completes.

Your First Monitor

Let's set up a comprehensive HTTP monitor step by step. This monitor will check your API endpoint from three regions, verify SSL, and confirm failures from multiple locations before triggering an incident.

curl -X POST https://api.media-luna.co/api/v1/monitors \
  -H "Authorization: Bearer $MEDIALUNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production API",
    "type": "HTTP",
    "url": "https://api.example.com/health",
    "check_interval": 60,
    "timeout": 15,
    "region_ids": [1, 2, 3],
    "confirm_from_locations": 2,
    "expected_status_codes": [200],
    "verify_ssl": true,
    "ssl_expiry_reminder": 14,
    "follow_redirects": true,
    "request_headers": {
      "Accept": "application/json"
    }
  }'

What happens next

1. Probe agents in your selected regions pick up the new monitor within 60 seconds
2. Each probe executes the HTTP check independently at the configured interval
3. Results are batched and submitted to the backend for processing
4. If a check fails, the system waits for confirmation from 2 regions before creating an incident
5. When an incident is created, notification rules are evaluated and alerts are dispatched

Understanding the Dashboard

The Media Luna dashboard gives you a real-time overview of your entire monitoring stack.

Monitor Status Summary

At the top of the dashboard you'll see aggregate counts:

Monitor Cards

Each monitor card displays the current status indicator, monitor name and URL, latest response time, uptime percentage over the selected time period, and when the last check ran.

Filtering & Search

• Search bar — find monitors by name or URL
• Tag filters — show only monitors matching specific tags
• Status filter — show only down, degraded, or up monitors
• View toggle — switch between grid (cards) and list (compact) layout

Time Range

Use the time range selector to view uptime and metrics over the last 24 hours, 7 days, 30 days, or 90 days.

Sidebar Navigation

Authentication Overview

Media Luna uses two distinct authentication mechanisms depending on the context:

Dashboard Authentication (JWT)

The dashboard uses HTTP-only cookie-based JWT authentication. When you sign in, the backend sets two cookies:

API Key Authentication

API keys provide programmatic access to the Developer API endpoints (prefixed /api/v1/).

Creating API Keys

1. Navigate to Settings → API Keys in the dashboard
2. Click "Create API Key" and provide a descriptive name
3. Select the scopes you need (least privilege recommended)
4. Copy and securely store the key — it's only shown once

Using API Keys

# Include in the Authorization header
curl https://api.media-luna.co/api/v1/monitors \
  -H "Authorization: Bearer sk_live_abc123..."

Key Permissions

Key Security

• Keys are SHA-256 hashed before storage — we cannot retrieve your full key
• Only the prefix (sk_live_abc) is stored in plaintext for identification
• Set expiration dates for keys used in CI/CD or temporary integrations
• Rotate keys regularly and revoke unused keys
• Never commit keys to source control — use environment variables

Roles & Permissions

Media Luna uses a three-tier role system. Roles are assigned at the user level and apply account-wide.

System Architecture

Media Luna follows a distributed architecture with clear separation between the API backend, probe agents, and the frontend dashboard.

┌─────────────────┐     ┌──────────────────────────────────────────┐
│   React App     │────▶│           FastAPI Backend                │
│   (Dashboard)   │◀────│  • REST API    • Auth (JWT + API Keys)   │
└─────────────────┘     │  • Incidents   • Notification Rules      │
                        │  • Billing     • Plan Limits             │
┌─────────────────┐     │  • Metrics     • Status Pages            │
│  Developer API  │────▶│                                          │
│  (sk_xxxxx)     │◀────└──────┬──────────────┬────────────────────┘
└─────────────────┘            │              │
                               │              │
                    ┌──────────▼──┐    ┌──────▼──────┐
                    │  PostgreSQL  │    │    Redis     │
                    │  (Primary)   │    │  • Cache     │
                    │  • Accounts  │    │  • Rate Lim  │
                    │  • Monitors  │    │  • Pub/Sub   │
                    │  • Incidents │    │  • Heartbeat │
                    │  • Metrics   │    └─────────────┘
                    └─────────────┘
                               ▲
         ┌─────────────────────┼─────────────────────┐
         │                     │                     │
┌────────┴────────┐  ┌────────┴────────┐  ┌────────┴────────┐
│  Probe Agent    │  │  Probe Agent    │  │  Probe Agent    │
│  us-east-1      │  │  us-west-1      │  │  eu-west-1      │
│  ┌────────────┐ │  │  ┌────────────┐ │  │  ┌────────────┐ │
│  │ Fetcher    │ │  │  │ Fetcher    │ │  │  │ Fetcher    │ │
│  │ Scheduler  │ │  │  │ Scheduler  │ │  │  │ Scheduler  │ │
│  │ Executor   │ │  │  │ Executor   │ │  │  │ Executor   │ │
│  │ Batcher    │ │  │  │ Batcher    │ │  │  │ Batcher    │ │
│  └────────────┘ │  │  └────────────┘ │  │  └────────────┘ │
└─────────────────┘  └─────────────────┘  └─────────────────┘

Multi-Tenancy

Media Luna is a multi-tenant platform with strict account-level data isolation. Every resource (monitors, incidents, metrics, users, notification channels, etc.) belongs to an account.

Account Hierarchy

# Every account has a plan that defines resource limits
Account
  ├── Plan (Free / Starter / Professional / Enterprise)
  ├── Users (Admin, Editor, Viewer)
  ├── Monitors
  │     ├── Metrics
  │     ├── Incidents → Timeline Events
  │     └── Tags
  ├── Notification Channels (Email, Slack, PagerDuty, ...)
  ├── Notification Rules → Conditions
  ├── Status Pages
  ├── Maintenance Windows
  └── API Keys

Probe Network

Probes are high-performance async Python agents deployed across geographic regions. Each probe can handle 10,000–30,000 concurrent health checks using uvloop and asyncio.

Probe Components

Probe Registration

Probes are dynamic. When a new probe starts, it registers with the backend, making its region available for assignment. This means you can scale probe coverage by simply deploying new instances.

# Probe configuration (docker-compose.yml)
probe-us-east:
  environment:
    AGENT_ID: "probe-us-east-1"
    REGION: "us-east-1"
    BACKEND_URL: "http://backend:8000"
    GLOBAL_CONCURRENCY: 300
    PER_TARGET_CONCURRENCY: 5
    BATCH_SIZE: 64

Region Confirmation

To prevent false positives caused by transient network issues, Media Luna supports multi-region confirmation. When enabled, a monitor must report a failure from N different probe regions before an incident is created.

# Example: Require 2 regions to confirm failure
{
  "name": "Critical API",
  "confirm_from_locations": 2,
  "region_ids": [1, 2, 3]
}

Region confirmation status is tracked in Redis with TTL-based expiration, ensuring stale failure signals don't persist. The backend uses a RegionConfirmationService that maintains a set of confirming regions per monitor and only creates an incident when the threshold is met.

Data Flow

Here's how a single health check flows through the system:

1. Fetcher polls /api/probe/monitors and receives monitors assigned to its region
2. Scheduler queues the check at the configured interval with randomized jitter
3. Executor performs the health check (HTTP, TCP, DNS, etc.) and records response time in milliseconds
4. Batcher collects the result and, when batch size is reached, gzip-compresses and POSTs to /api/probe/results
5. Backend processes results: updates monitor status, stores metrics, evaluates region confirmation
6. If status changes (UP→DOWN or DOWN→UP), an Incident is created/resolved
7. Notification Rule Evaluator checks all rules against the new state
8. Matching rules dispatch alerts via the Notification Manager to configured channels

Monitor Types

Media Luna supports seven check protocols plus push-based heartbeats:

Check Configuration

Each monitor type supports specific configuration options:

HTTP Options

Timing

Choosing the Right Interval

Heartbeat / Cron Job Monitoring

Heartbeat monitors (also called push monitors) invert the usual model: instead of Media Luna reaching out to check your service, your service periodically pings a unique Media Luna URL. If a ping isn't received within the expected window, an incident is triggered. This is ideal for cron jobs, background workers, queue consumers, and any process that should run on a schedule.

Creating a Heartbeat Monitor

1. Go to Monitors → Add Monitor
2. Select Heartbeat / Push as the type
3. Set the expected interval — how often your service will ping (e.g. every 5 minutes for a 5-minute cron)
4. Set the grace period — how late a ping can arrive before an incident is triggered (e.g. 2 minutes)
5. Click Create Monitor — Media Luna generates a unique ping URL for this monitor

Integrating the Ping URL

Copy the generated ping URL and add an HTTP GET request at the end of your job:

# Cron job example (bash)
#!/bin/bash
# Run your job first
python /app/scripts/nightly_report.py

# Signal success to Media Luna
curl -s "https://hb.media-luna.co/ping/abc123xyz" --max-time 5 --silent || true

# Python example (schedule library)
import requests

def my_job():
    # ... do work ...
    requests.get("https://hb.media-luna.co/ping/abc123xyz", timeout=5)

# crontab entry
*/5 * * * *  /usr/bin/python3 /app/worker.py && curl -s https://hb.media-luna.co/ping/abc123xyz

How It Works

Next steps: Set up notification rules for this monitor →

SSL Certificate Monitoring

HTTP monitors with verify_ssl: true automatically monitor SSL certificate validity. Use ssl_expiry_reminder to get notified before your certificate expires.

What's tracked

• Certificate validity and expiration date
• Certificate chain completeness
• Domain name match
• Issuer information

Common Issues

Domain Expiry Monitoring

Media Luna checks your domain expiration dates via WHOIS lookups and creates an incident before your domain lapses. An expired domain instantly takes your entire service offline — recovery can take days and often costs more than the renewal itself.

Enabling Domain Expiry Reminders

Set the domain_expiry_reminder field on any HTTP monitor to receive an advance warning incident before your domain expires:

curl -X POST https://api.media-luna.co/api/v1/monitors \
  -H "Authorization: Bearer $MEDIALUNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "example.com domain",
    "type": "HTTP",
    "url": "https://example.com",
    "domain_expiry_reminder": 30
  }'

In the example above, Media Luna opens a domain_expiry incident 30 days before the domain expires, giving you ample time to renew.

How WHOIS Monitoring Works

Media Luna periodically performs WHOIS lookups for the domain of your HTTP monitor's URL. The expiration date is parsed from the WHOIS record and compared to the current date. When the remaining days fall at or below your configured reminder window, an incident of type domain_expiry is created and your notification rules are evaluated.

Recommended Reminder Windows

Next steps: SSL Certificate Monitoring →

Tags & Organization

Use tags to organize, filter, and group your monitors effectively.

Creating Tags

Go to any monitor's settings, find the Tags field, type a tag name and press Enter — or select from existing tags.

Recommended Naming Conventions

Bulk Monitor Import

If you're migrating from another monitoring tool or setting up monitoring for many services at once, Media Luna supports bulk import via CSV or JSON. Import hundreds of monitors in seconds without creating each one individually.

CSV Import

Navigate to Monitors → Import and upload a .csv file. Required columns are name and url; all others are optional and fall back to platform defaults.

# monitors.csv
name,type,url,check_interval,tags
Production API,HTTP,https://api.example.com/health,60,"production,api,critical"
Staging Site,HTTP,https://staging.example.com,300,"staging,web"
Mail Server,SMTP,mail.example.com,300,"production,email"
Auth Service TCP,TCP,auth.example.com:443,60,"production,auth"

JSON Import

For more control, upload a JSON array of monitor objects. Every field supported by the Create Monitor API endpoint can be specified.

[
  {
    "name": "Production API",
    "type": "HTTP",
    "url": "https://api.example.com/health",
    "check_interval": 60,
    "region_ids": [1, 2],
    "expected_status_codes": [200],
    "tags": ["production", "api"],
    "verify_ssl": true
  },
  {
    "name": "Database Port",
    "type": "TCP",
    "host": "db.example.com",
    "port": 5432,
    "check_interval": 60,
    "tags": ["production", "database"]
  }
]

Smart Domain Discovery

Media Luna can automatically suggest monitors based on a root domain. Enter example.com in the Smart Discovery tool and Media Luna scans for common subdomains and services (www, api, mail, status, etc.), presenting a checklist you can import in one click.

Import Validation

Before monitors are created, the import validates each row for required fields and plan limits. A preview screen shows which rows will succeed and which have errors, so you can fix issues before committing the import.

Maintenance Windows

Schedule maintenance windows to pause alerting during planned downtime. When a monitor is in a maintenance window, checks still run (preserving your uptime data) but incidents are not created and no notifications are sent.

Creating a Maintenance Window

1. Go to Monitors and select one or more monitors
2. Click Schedule Maintenance (or use the bulk actions menu)
3. Set the start and end date/time in your account timezone
4. Optionally add a description (e.g. "Database migration v2.1")
5. Click Schedule

Recurring Maintenance

For services with regular maintenance schedules (nightly backups, weekly deployments), configure a recurring window:

Behaviour During Maintenance

• Active incidents are automatically resolved when the window starts
• Failures during the window are silently recorded in metrics but do not trigger incidents
• Uptime percentage calculations can optionally exclude maintenance windows for accurate SLA reporting
• When the window ends, normal monitoring resumes immediately

Next steps: Organizing Monitors with Tags →

Incident Lifecycle

Incidents are automatically created when a monitor's status changes to DOWN (or other failure conditions). Each incident follows a clear lifecycle:

TRIGGERED  ──▶  ACKNOWLEDGED  ──▶  RESOLVED
    │                                        ▲
    │             SNOOZED                  │
    │                │                       │
    └────────────────┴───────────────────────┘
           (auto-resolves when UP)

Incident Types

Timeline Events

Every incident maintains a timeline of events for post-mortem analysis. Events are automatically created for lifecycle transitions, and you can add manual comments.

Acknowledging Incidents

Acknowledging an incident signals to your team that someone is aware of and investigating the issue.

How to Acknowledge

• Incidents list — Click the Acknowledge button next to the incident
• Incident detail — Click Acknowledge in the header
• Email notification — Click the acknowledge link in the alert email
• Slack notification — Click the acknowledge action in the Slack message

What Happens

1. Incident status changes to Acknowledged
2. Your name and timestamp are recorded in the timeline
3. Your team sees the incident is being handled
4. Optionally pauses repeated notifications

Snoozing Alerts

Snoozing temporarily pauses notifications for an incident without resolving it. Useful during planned maintenance, known issues being worked on, or after-hours incidents you'll handle later.

How to Snooze

1. Open the incident
2. Click Snooze
3. Select duration: 30 minutes, 1 hour, 4 hours, 8 hours, until tomorrow, or custom
4. Optionally add a note explaining why

Behavior

• Notifications are paused for the duration
• Incident remains active and visible
• Snooze event is recorded in the timeline
• Can be cancelled early or renewed
• When the snooze expires, if the incident is still active, notifications resume

Flap Prevention

Flapping occurs when a monitor rapidly alternates between UP and DOWN states, generating a flood of redundant notifications. Media Luna provides two mechanisms to prevent this: consecutive check thresholds in notification rules, and multi-region confirmation on monitors.

Consecutive Check Thresholds

Set consecutive_checks on a notification rule to require that a condition be met N times in a row before a notification fires. This eliminates noise from transient blips.

{
  "name": "Confirmed downtime alert",
  "consecutive_checks": 3,  // 3 consecutive failures required
  "conditions": [
    { "type": "STATUS", "operator": "eq", "value": "down" }
  ],
  "channel_ids": [1]
}

Choosing the Right Threshold

Multi-Region Confirmation

Use confirm_from_locations to require that multiple probe regions independently observe the failure before an incident is created. This prevents false positives caused by a single probe's connectivity issue. See Region Confirmation →

Incident Comments & Timeline

Every incident has a chronological timeline that records automatic lifecycle events and manual team communications. Use comments to document your investigation, capture findings, and build a complete post-mortem record.

Adding a Comment

1. Open the incident from the Incidents list
2. Scroll to the Timeline section at the bottom
3. Type your message in the comment box
4. Click Add Comment

Comments are visible to all team members with access to the incident. Use them to share:

• Investigation findings ("Checked logs — elevated error rate on db-replica-2")
• Steps taken ("Restarted the service at 14:32 UTC")
• External links ("See runbook: https://wiki.example.com/runbooks/db")
• Root cause analysis once the incident is resolved

Via the API

curl -X POST https://api.media-luna.co/api/incidents/156/timeline \
  -H "Authorization: Bearer $MEDIALUNA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Root cause identified: misconfigured load balancer rule. Fix deployed at 15:10 UTC."}'

Timeline Event Reference

Notification Rules

Notification rules are separate from incidents. Incidents represent what happened; rules define when and how to alert.

Creating a Rule

1. Go to Notification Rules
2. Click Create Rule
3. Select monitors (all, specific, or by tag)
4. Configure trigger conditions
5. Select notification channels
6. Save the rule

Rule Conditions

Each rule has one or more conditions that must be met before a notification fires:

{
  "name": "Slow response alert",
  "conditions": [
    {
      "type": "RESPONSE_TIME",
      "operator": "gt",
      "value": 2000          // milliseconds
    }
  ],
  "consecutive_checks": 3,  // must fail 3 times in a row
  "channel_ids": [1, 3]
}

Example Configurations

Escalation Policies

Escalation policies ensure unacknowledged incidents eventually reach the right people. When a notification is sent but nobody acknowledges within a configured window, Media Luna escalates by notifying a secondary set of channels or individuals.

How Escalation Works

1. A notification rule fires and sends alerts to the primary channels
2. If the incident is not acknowledged within the escalation delay, a second notification goes to escalation channels
3. Escalation can be chained — if still unacknowledged after another delay, a third tier fires
4. Escalation stops automatically when the incident is acknowledged or resolved

Configuring Escalations

Add escalation steps to any notification rule via the dashboard or API:

{
  "name": "Critical API — with escalation",
  "channel_ids": [1],  // primary: Slack #alerts-critical
  "escalation_steps": [
    {
      "delay_minutes": 15,
      "channel_ids": [2]  // after 15 min: PagerDuty on-call
    },
    {
      "delay_minutes": 30,
      "channel_ids": [3, 4]  // after 30 min: SMS to engineering lead
    }
  ]
}

Escalation vs. Repeated Notifications

Tag-Based Routing

Instead of selecting specific monitors in a notification rule, target monitors by their tags. This makes rules dynamic — any monitor with a matching tag is automatically included, even those created after the rule was written.

Setting Up Tag-Based Rules

1. Go to Notification Rules → Create Rule
2. Under Monitors, choose By Tag
3. Enter one or more tag names (e.g. production, critical)
4. Configure conditions and channels as normal

Example Routing Strategy

Next steps: Monitor Tags & Organization →

Notification Channels

Channels define how alerts are delivered. Media Luna supports six channel types:

After configuring a channel, always click Test to verify delivery before relying on it for production alerts.

Webhooks

When using the Webhook notification channel, Media Luna sends a POST request with a JSON payload to your configured URL on each alert.

Payload Format

{
  "event": "incident.triggered",
  "timestamp": "2026-03-21T09:15:00Z",
  "incident": {
    "id": 156,
    "status": "triggered",
    "incident_type": "downtime",
    "message": "HTTP 503 Service Unavailable"
  },
  "monitor": {
    "id": 12,
    "name": "Payment API",
    "url": "https://payments.example.com/health",
    "type": "HTTP"
  },
  "check": {
    "response_time_ms": null,
    "status_code": 503,
    "region": "us-east-1"
  }
}

Webhook Events

Verifying Webhook Signatures

If you set a secret, Media Luna includes a signature header:

X-Media-Luna-Signature: sha256=abc123...

Verify by computing HMAC-SHA256 of the raw payload body using your secret.

Slack Integration

Receive incident notifications directly in your Slack workspace.

Setup

1. Go to Notification Channels → Add Channel → Slack
2. Click Connect to Slack and authorize Media Luna in your workspace
3. Select the channel for notifications
4. Click Test to verify the connection

What You'll Receive

Multiple Channels

Route different alerts to different Slack channels:

• #alerts-critical — production monitors only
• #alerts-staging — staging environment
• #engineering — all alerts for visibility

PagerDuty Integration

Connect Media Luna with PagerDuty for enterprise on-call incident management.

Getting Your Integration Key

1. Log in to PagerDuty → Services → Service Directory
2. Select or create a service for Media Luna alerts
3. Go to Integrations tab → Add Integration
4. Select Events API v2
5. Copy the Integration Key

Setup in Media Luna

1. Go to Notification Channels → Add Channel → PagerDuty
2. Paste your Integration Key
3. Name the channel and click Save
4. Click Test to send a test incident

Incident Mapping

Email Notifications

Email is the default notification channel. Your account email automatically receives incident alerts.

Adding Recipients

1. Go to Notification Channels → Add Channel → Email
2. Enter the email address
3. Recipient verifies their email via a confirmation link

Email Content

Troubleshooting

• Check your spam/junk folder
• Verify the email address is correct in Notification Channels
• Make sure you have notification rules configured for the monitor
• Whitelist [email protected]

Microsoft Teams Integration

Send incident notifications directly to a Microsoft Teams channel using an Incoming Webhook connector.

Setup

1. In Microsoft Teams, open the channel where you want to receive alerts
2. Click … (More options) next to the channel name → Connectors
3. Find Incoming Webhook and click Configure
4. Give it a name (e.g. "Media Luna Alerts") and optionally upload an icon
5. Click Create and copy the webhook URL
6. In Media Luna, go to Notification Channels → Add Channel → Microsoft Teams
7. Paste the webhook URL and click Save
8. Click Test to send a test card to your channel

What You'll Receive

Media Luna sends an Adaptive Card to your Teams channel with color-coded status, monitor name, incident type, error message, and a direct link to the incident in the dashboard.

Discord Integration

Deliver monitoring alerts to a Discord server channel via Discord's built-in webhook support.

Setup

1. In Discord, open your server and go to the channel where you want alerts
2. Click the gear icon (Edit Channel) → Integrations → Webhooks
3. Click New Webhook, give it a name, and optionally set an avatar
4. Click Copy Webhook URL
5. In Media Luna, go to Notification Channels → Add Channel → Discord
6. Paste the webhook URL and click Save
7. Click Test to verify the connection

What You'll Receive

Telegram Integration

Receive monitoring alerts via Telegram — great for on-call engineers who prefer mobile notifications or for teams that use Telegram as their primary communication platform.

Setup

1. Open Telegram and search for @BotFather
2. Send /newbot and follow the prompts to create a bot
3. Copy the API token BotFather provides
4. Start a chat with your new bot (or add it to a group) and send any message to it
5. Retrieve your chat ID by visiting: https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
6. In Media Luna, go to Notification Channels → Add Channel → Telegram
7. Enter your bot token and chat ID, then click Save
8. Click Test to send a test message

Chat Target Options

SMS Notifications (Twilio)

SMS notifications provide the highest-urgency delivery for critical incidents. Media Luna uses Twilio to send text messages worldwide. SMS is ideal for on-call scenarios where the recipient may not be near a computer or have push notifications enabled.

Setup

1. Go to Notification Channels → Add Channel → SMS
2. Enter the phone number in E.164 format (e.g. +14155552671)
3. Click Send Verification Code — a 6-digit code is texted to the number
4. Enter the code to confirm ownership of the number
5. Click Save

Message Format

SMS alerts are concise for readability on any device:

⚠ TRIGGERED: Payment API is DOWN
Error: HTTP 503 Service Unavailable
Region: us-east-1
https://app.media-luna.co/incidents/156

✅ RESOLVED: Payment API is UP
Duration: 4m 32s
https://app.media-luna.co/incidents/156

Creating a Status Page

Status pages let you communicate service availability to your users with a branded, public-facing page.

Setup

1. Go to Status Pages in the sidebar
2. Click Create Status Page
3. Set the page name and subdomain (your-name.media-luna.co)
4. Select which monitors to display
5. Click Publish

Adding Monitors

Select which monitors appear on your page. Rename them for public display:

Component Groups

Organize monitors into logical groups for your audience:

• Core Services: API, Website, Database
• Integrations: Slack, Webhooks, Email
• Regional: US, EU, Asia

Customizing Status Pages

Make your status page match your brand.

Visual Options

Custom Domain (Pro+)

Use your own domain for a professional look:

1. Add a CNAME record pointing to Media Luna
2. Enter your domain in status page settings
3. SSL certificate is automatically provisioned

Visibility Settings

Control who can view your status page.

Status Page Email Subscribers

Allow your users and stakeholders to subscribe to your status page for automatic email notifications when a component goes down, recovers, or when you post a public incident update. Subscribers opt in voluntarily, keeping you compliant with email regulations.

How Subscription Works

1. A visitor to your status page clicks Subscribe to Updates
2. They enter their email address
3. They receive a confirmation email and click to verify their subscription
4. They will now receive email notifications for the status page's components

Managing Subscribers

In your status page settings, go to the Subscribers tab to:

• View all active subscribers and their subscription date
• Manually add subscribers (useful for internal stakeholders)
• Remove individual subscribers
• Export the subscriber list as CSV

What Triggers Subscriber Emails

Posting Incident Updates

During an outage, keeping your users informed reduces support ticket volume and builds trust. Use incident updates on your status page to communicate what happened, what you're doing about it, and when you expect resolution.

Creating a Public Update

1. Navigate to your Status Page in the dashboard
2. Find the active incident in the Active Incidents section
3. Click Post Update
4. Select a severity label: Investigating, Identified, Monitoring, or Resolved
5. Write your message and click Publish

Updates are immediately visible on your public status page and emailed to all subscribers.

Update Status Labels

Scheduled Maintenance Announcements

Post advance notice for planned maintenance directly on your status page:

1. Go to your status page → Schedule Maintenance
2. Set the start and end time, affected components, and a description
3. Publish — subscribers receive the notice immediately
4. Another notification is sent when the window starts and again when it ends

Next steps: Managing Subscribers →

Uptime Report

The Uptime Report provides a historical view of availability for each of your monitors. Use it to understand long-term reliability trends, identify monitors with recurring issues, and share availability data with stakeholders.

Accessing the Report

1. Navigate to Reports → Uptime in the sidebar
2. Select the time range: 7 days, 30 days, 90 days, or custom
3. Filter by tag, monitor type, or specific monitors
4. Export to CSV or PDF for sharing

Report Metrics

Uptime Calculation

Uptime is calculated from check results, not incident records. Each check is either a success or failure; uptime % is the ratio of successes to total checks. Maintenance windows can be excluded from the calculation so planned downtime doesn't penalise your uptime score.

Performance Report

The Performance Report provides detailed response time analytics across your monitors. Identify slow endpoints, track improvements after optimisations, and set SLO targets for response time.

Key Metrics

Per-Region Breakdown

Response times are reported per probe region, letting you identify geographic performance disparities. If your API responds in 80 ms from us-east but 400 ms from eu-west, you may benefit from deploying a CDN or edge node closer to European users.

Time-Series Charts

The performance report includes a time-series chart of response times overlaid with incident markers. This makes it easy to correlate slow response periods with deployments, traffic spikes, or infrastructure events.

Next steps: SLA Compliance Report →

SLA Compliance Report

The SLA Report helps you measure and communicate compliance against uptime targets. Whether you have contractual SLAs with customers or internal SLOs, this report provides the data you need.

Setting SLA Targets

Define an SLA target per monitor in monitor settings. Common targets and their allowed downtime:

Report Contents

Exporting SLA Reports

Export as PDF for sharing with customers or leadership, or as CSV for importing into your own dashboards and ticketing systems. Reports can be scheduled for automatic monthly delivery to specified email recipients.

Next steps: Uptime Report →

Account Settings

Click your profile icon and select Settings, or navigate from the sidebar.

Profile

Preferences

Team Management

Invite team members and manage access to your Media Luna account. Requires Admin role.

Inviting Members

1. Go to Settings → Team
2. Click Invite Member
3. Enter their email address and select a role
4. Click Send Invitation

The invitee receives an email, clicks the invitation link, creates an account (or links an existing one), and gets immediate access.

Managing Members

• Change role — Click the role dropdown next to any member
• Remove member — Click Remove and confirm
• Pending invitations — View, resend, or cancel outstanding invites

Two-Factor Authentication

Add an extra layer of security with TOTP-based two-factor authentication.

Enabling 2FA

1. Go to Settings → Security
2. Click Enable Two-Factor Authentication
3. Scan the QR code with your authenticator app (Google Authenticator, Authy, 1Password, etc.)
4. Enter the 6-digit verification code
5. Save your backup codes — each code can be used once if you lose your authenticator

Logging In with 2FA

1. Enter email and password as usual
2. Open your authenticator app
3. Enter the 6-digit code

Lost Access?

• Use one of your backup codes
• Contact [email protected] with account verification

Plan Comparison

Media Luna offers four plans to fit teams of any size:

Limits & Quotas

Resource creation is validated against your current plan. When a limit is reached, the API returns a 403 with a descriptive error message.

// Example: Monitor limit reached
{
  "detail": "Monitor limit reached. Your Free plan allows 20 monitors. Upgrade to create more.",
  "status_code": 403
}

// Example: Region limit exceeded
{
  "detail": "Region limit exceeded. Your Starter plan allows 2 regions per monitor.",
  "status_code": 403
}

Rate Limits

Approaching Limits

You'll be notified when reaching 80% of your monitor or team member limits. If you exceed limits after a downgrade, existing resources continue working but you cannot create new ones until usage is reduced.

Check your current usage at any time via the Usage & Limits API endpoint.

Billing Management

Manage your subscription, payment methods, and invoices from Settings → Billing. Requires Admin role.

Upgrading Your Plan

1. Go to Settings → Billing → Upgrade Plan
2. Select your new plan
3. Enter payment information
4. Confirm — new limits apply immediately

Billing is prorated: you pay the difference for the remaining days in your current cycle.

Payment Methods

Accepted: Visa, Mastercard, American Express, Discover. Payments processed securely via Stripe (PCI DSS compliant). We never store full card numbers.

Invoices

View all past invoices in Settings → Billing → Billing History. Each invoice shows the date, amount, payment method, and status. Download PDF invoices for accounting.

Downgrading

Go to Settings → Billing → Change Plan. The downgrade takes effect at the end of your current billing period. Make sure you're within the new plan's limits before the switch.

Cancellation & Data Export

You can cancel your Media Luna subscription at any time. There are no long-term contracts or cancellation fees. Your account transitions to the Free plan at the end of your current billing period — you will not be charged again.

How to Cancel

1. Go to Settings → Billing
2. Click Cancel Plan
3. Select a cancellation reason (optional, but helps us improve)
4. Click Confirm Cancellation

Your paid features remain active until the end of the billing period. After that, the account automatically moves to the Free plan with its associated limits.

What Happens on Downgrade to Free

• Monitors above the Free limit (20) are paused — not deleted
• Team members above the Free limit (1) retain read-only access until removed
• Check intervals revert to the Free minimum (5 minutes)
• Status pages above the Free limit (1) are unpublished but preserved
• Historical data beyond 7 days becomes inaccessible (retained for 30 days if you re-upgrade)

Exporting Your Data Before Cancellation

Export your data from Settings → Data Export before cancelling:

Full Account Deletion

To permanently delete your account and all data, go to Settings → Danger Zone → Delete Account. This action is irreversible. All monitors, incidents, metrics, team members, status pages, and billing history will be permanently erased within 30 days. Database backups are purged within 90 days.

Security Overview

Media Luna is built with security as a top priority.

Infrastructure

Application

Reporting Vulnerabilities

Found a security issue? Report responsibly to [email protected]. We respond within 24 hours and maintain a bug bounty program.

Data Privacy

What We Collect

What We Don't Do

• We don't sell your data
• We don't share with advertisers
• We don't read your application data

Your Rights

Privacy questions: [email protected]

Data Retention

Data is retained based on your plan:

Account Deletion

When you delete your account, all data is deleted within 30 days and backups are purged within 90 days. Export your data before deletion if needed.

Compliance

Data Residency

Choose where your data is stored: United States (default), European Union, or custom regions (Enterprise).

Documentation

Available on request: security questionnaires, penetration test summaries, architecture documentation, and vendor security assessments.

Compliance inquiries: [email protected]