Monitors API

Learn how to programmatically create and manage monitors using the Bareuptime API.

Prerequisites

Before you start, you'll need to:

1. Generate an API Key: Visit https://app.bareuptime.co/api-keys
2. Log in to your Bareuptime account
3. Click "Generate New Key" and copy the API key
4. Store securely - you won't be able to see it again

Base URL

https://api.bareuptime.co/v1

Authentication

Include your API key in all requests:

Authorization: Bearer YOUR_API_KEY

Create a Monitor

Endpoint

POST /monitors

Request Body

{
  "name": "My Website",
  "url": "https://example.com",
  "check_interval": "5min",
  "type": "get",
  "request_body": "",
  "request_headers": "",
  "monitor_type": "http"
}

Field Descriptions

Field	Type	Required	Description
name	string	✅	Monitor name
url	string	✅	URL to monitor (must use HTTPS)
check_interval	string	✅	Check intervals - Free: 10min, 20min, 30min, 1hr | Premium: 1min, 5min + Free | Advanced: 6hr | Email: 24hr
type	string		HTTP method: get, post, put, patch, delete (default: get)
request_body	string		Request body for POST/PUT/PATCH requests
request_headers	string		Custom HTTP headers as JSON string
monitor_type	string		Monitor type: http, keyword, advanced_page_monitoring, email_domain (default: http)

Monitor Types

Type	Description	Plan Required	Check Intervals	Features
http	Basic HTTP/HTTPS monitoring	Free/Premium	Free: 10min-1hr | Premium: 1min-1hr	URL availability, response time, status codes, SSL monitoring (daily)
keyword	Content monitoring	Free/Premium	Free: 10min-1hr | Premium: 1min-1hr	HTTP monitoring + keyword/content checking, SSL monitoring (daily)
advanced_page_monitoring	Comprehensive page analysis	Premium	1hr only (fixed)	Page load time, domain expiry, robot blockage detection, SSL monitoring (daily)
email_domain	Email domain health	Premium	1hr only (fixed)	MX record validation, spam reputation checking, SSL monitoring (daily)

Notes

• Timeout: Fixed at 5 seconds for all monitors
• Retry Count: Fixed at 3 retries for all monitors
• Premium HTTP Methods: post, put, patch, delete require premium plan
• Premium Monitor Types: advanced_page_monitoring, email_domain require premium plan
• Free Plan: Limited to 10min, 20min, 30min, 1hr intervals
• Premium Plan: Can use 1min, 5min + all free plan intervals
• SSL Monitoring: Automatic SSL certificate monitoring (daily) on all endpoints
• Advanced Page Monitoring: Uses 1hr intervals (optimized for comprehensive analysis)
• Email Domain Monitoring: Uses 1hr intervals (optimized for daily infrastructure checks)

Available Locations

Location Code	Region	Free Plan	Premium Plan
iowa	Iowa, USA	✅	✅
germany	Germany (Falkenstein)	✅	✅
us-west	US West (California)	❌	✅
asia	Asia Pacific (Singapore)	❌	✅

Examples

cURL

Basic HTTP Monitor

Basic HTTP Monitor

curl -X POST https://api.bareuptime.co/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Company Website",
    "url": "https://company.com",
    "check_interval": "5min",
    "type": "get",
    "monitor_type": "http"
  }'

API Endpoint with Authentication

curl -X POST https://api.bareuptime.co/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "API Health Check",
    "url": "https://api.company.com/health",
    "check_interval": "1min",
    "type": "get",
    "request_headers": "{\"Authorization\": \"Bearer api-token-123\", \"X-API-Version\": \"v1\"}"
  }'

POST Request Monitor

curl -X POST https://api.bareuptime.co/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "User Registration Test",
    "url": "https://api.company.com/test/register",
    "check_interval": "10min",
    "type": "post",
    "monitor_type": "http",
    "request_headers": "{\"Content-Type\": \"application/json\", \"X-Test-Mode\": \"true\"}",
    "request_body": "{\"test\": true, \"email\": \"test@example.com\"}"
  }'

Advanced Page Monitoring (Premium)

curl -X POST https://api.bareuptime.co/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Complete Website Analysis",
    "url": "https://mywebsite.com",
    "check_interval": "1hr",
    "type": "get",
    "monitor_type": "advanced_page_monitoring"
  }'

Email Domain Monitoring (Premium)

curl -X POST https://api.bareuptime.co/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Company Email Domain",
    "url": "https://company.com", 
    "check_interval": "1hr",
    "type": "get",
    "monitor_type": "email_domain"
  }'

JavaScript

JavaScript/Node.js

Installation

npm install node-fetch
# or
npm install axios

Using fetch (Node.js 18+ or with polyfill)

const API_KEY = process.env.BAREUPTIME_API_KEY;
const API_BASE = 'https://api.bareuptime.co/v1';

async function createMonitor(monitorData) {
  const response = await fetch(`${API_BASE}/monitors`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(monitorData)
  });

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

  return await response.json();
}

// Example usage
const monitor = {
  name: 'My Website',
  url: 'https://example.com',
  check_interval: '5min',
  type: 'get',
  monitor_type: 'http'
};

createMonitor(monitor)
  .then(result => console.log('Monitor created:', result))
  .catch(error => console.error('Error:', error));

Using axios

const axios = require('axios');

const API_KEY = process.env.BAREUPTIME_API_KEY;
const API_BASE = 'https://api.bareuptime.co/v1';

const client = axios.create({
  baseURL: API_BASE,
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  }
});

async function createMonitor(monitorData) {
  try {
    const response = await client.post('/monitors', monitorData);
    return response.data;
  } catch (error) {
    if (error.response) {
      // Server responded with error status
      console.error('Error:', error.response.data);
      throw new Error(`API Error: ${error.response.status}`);
    } else {
      // Network or other error
      console.error('Network Error:', error.message);
      throw error;
    }
  }
}

// Create API monitor with authentication
const apiMonitor = {
  name: 'API Health Check',
  url: 'https://api.company.com/health',
  type: 'http',
  interval: 60,
  method: 'GET',
  headers: {
    'Authorization': 'Bearer api-token-123'
  },
  expected_status_codes: [200],
  response_contains: 'healthy',
  locations: ['iowa', 'germany'],
  tags: ['api', 'critical']
};

createMonitor(apiMonitor);

TypeScript

TypeScript

interface Monitor {
  name: string;
  url: string;
  check_interval: '1min' | '5min' | '10min' | '20min' | '30min' | '1hr';
  type: 'get' | 'post' | 'put' | 'patch' | 'delete';
  request_body?: string;
  request_headers?: string;
}

interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: {
    code: string;
    message: string;
  };
}

class BareuprimeClient {
  private apiKey: string;
  private baseUrl: string = 'https://api.bareuptime.co/v1';

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async createMonitor(monitor: Monitor): Promise<ApiResponse<any>> {
    const response = await fetch(`${this.baseUrl}/monitors`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(monitor)
    });

    return await response.json();
  }

  async getMonitors(): Promise<ApiResponse<any[]>> {
    const response = await fetch(`${this.baseUrl}/monitors`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    return await response.json();
  }

  async deleteMonitor(monitorId: string): Promise<ApiResponse<any>> {
    const response = await fetch(`${this.baseUrl}/monitors/${monitorId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    return await response.json();
  }
}

// Usage example
const client = new BareuprimeClient(process.env.BAREUPTIME_API_KEY!);

const monitor: Monitor = {
  name: 'E-commerce API',
  url: 'https://api.shop.com/v1/health',
  check_interval: '5min',
  type: 'get'
};

client.createMonitor(monitor)
  .then(result => {
    if (result.success) {
      console.log('Monitor created successfully:', result.data);
    } else {
      console.error('Error creating monitor:', result.error);
    }
  });

Python

Python

Installation

pip install requests

Basic Example

import os
import requests
import json

class BareuprimeClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.bareuptime.co/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def create_monitor(self, monitor_data):
        """Create a new monitor"""
        response = requests.post(
            f"{self.base_url}/monitors",
            headers=self.headers,
            json=monitor_data
        )
        
        if response.status_code != 201:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        return response.json()
    
    def get_monitors(self):
        """Get all monitors"""
        response = requests.get(
            f"{self.base_url}/monitors",
            headers=self.headers
        )
        
        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        return response.json()
    
    def update_monitor(self, monitor_id, monitor_data):
        """Update an existing monitor"""
        response = requests.put(
            f"{self.base_url}/monitors/{monitor_id}",
            headers=self.headers,
            json=monitor_data
        )
        
        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        return response.json()
    
    def delete_monitor(self, monitor_id):
        """Delete a monitor"""
        response = requests.delete(
            f"{self.base_url}/monitors/{monitor_id}",
            headers=self.headers
        )
        
        if response.status_code != 204:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        return True

# Usage example
def main():
    # Get API key from environment variable
    api_key = os.environ.get('BAREUPTIME_API_KEY')
    if not api_key:
        raise ValueError("BAREUPTIME_API_KEY environment variable is required")
    
    client = BareuprimeClient(api_key)
    
    # Create a website monitor
    website_monitor = {
        "name": "Company Homepage",
        "url": "https://company.com",
        "check_interval": "5min",
        "type": "get"
    }
    
    try:
        result = client.create_monitor(website_monitor)
        print("Monitor created successfully:")
        print(json.dumps(result, indent=2))
        
        monitor_id = result['data']['id']
        
        # Create an API monitor with headers
        api_monitor = {
            "name": "User API Health Check",
            "url": "https://api.company.com/users/health",
            "check_interval": "1min",
            "type": "get",
            "request_headers": "Authorization: Bearer api-token-123\nX-Client: monitoring"
        }
        
        api_result = client.create_monitor(api_monitor)
        print("API monitor created successfully:")
        print(json.dumps(api_result, indent=2))
        
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

Go

Go

Installation

go mod init monitor-creator
go get -u github.com/go-resty/resty/v2

Example Code

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    
    "github.com/go-resty/resty/v2"
)

type Monitor struct {
    Name          string `json:"name"`
    URL           string `json:"url"`
    CheckInterval string `json:"check_interval"`
    Type          string `json:"type"`
    RequestBody   string `json:"request_body,omitempty"`
    RequestHeaders string `json:"request_headers,omitempty"`
}

type ApiResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data,omitempty"`
    Error   *ApiError   `json:"error,omitempty"`
}

type ApiError struct {
    Code    string `json:"code"`
    Message string `json:"message"`
}

type BareuprimeClient struct {
    client  *resty.Client
    baseURL string
    apiKey  string
}

func NewBareuprimeClient(apiKey string) *BareuprimeClient {
    client := resty.New()
    client.SetHeader("Authorization", "Bearer "+apiKey)
    client.SetHeader("Content-Type", "application/json")
    
    return &BareuprimeClient{
        client:  client,
        baseURL: "https://api.bareuptime.co/v1",
        apiKey:  apiKey,
    }
}

func (c *BareuprimeClient) CreateMonitor(monitor Monitor) (*ApiResponse, error) {
    var result ApiResponse
    
    resp, err := c.client.R().
        SetBody(monitor).
        SetResult(&result).
        Post(c.baseURL + "/monitors")
    
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    
    if resp.StatusCode() != 201 {
        return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode(), resp.String())
    }
    
    return &result, nil
}

func (c *BareuprimeClient) GetMonitors() (*ApiResponse, error) {
    var result ApiResponse
    
    resp, err := c.client.R().
        SetResult(&result).
        Get(c.baseURL + "/monitors")
    
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    
    if resp.StatusCode() != 200 {
        return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode(), resp.String())
    }
    
    return &result, nil
}

func (c *BareuprimeClient) DeleteMonitor(monitorID string) error {
    resp, err := c.client.R().
        Delete(c.baseURL + "/monitors/" + monitorID)
    
    if err != nil {
        return fmt.Errorf("request failed: %w", err)
    }
    
    if resp.StatusCode() != 204 {
        return fmt.Errorf("API error: %d - %s", resp.StatusCode(), resp.String())
    }
    
    return nil
}

func main() {
    // Get API key from environment variable
    apiKey := os.Getenv("BAREUPTIME_API_KEY")
    if apiKey == "" {
        log.Fatal("BAREUPTIME_API_KEY environment variable is required")
    }
    
    client := NewBareuprimeClient(apiKey)
    
    // Create a website monitor
    websiteMonitor := Monitor{
        Name:          "Company Website",
        URL:           "https://company.com",
        CheckInterval: "5min",
        Type:          "get",
    }
    
    result, err := client.CreateMonitor(websiteMonitor)
    if err != nil {
        log.Fatalf("Failed to create website monitor: %v", err)
    }
    
    fmt.Println("Website monitor created successfully:")
    resultJSON, _ := json.MarshalIndent(result, "", "  ")
    fmt.Println(string(resultJSON))
    
    // Create an API monitor with authentication
    apiMonitor := Monitor{
        Name:           "API Health Check",
        URL:            "https://api.company.com/health",
        CheckInterval:  "1min",
        Type:           "get",
        RequestHeaders: "Authorization: Bearer api-token-123\nX-Client: monitoring",
    }
    
    apiResult, err := client.CreateMonitor(apiMonitor)
    if err != nil {
        log.Fatalf("Failed to create API monitor: %v", err)
    }
    
    fmt.Println("API monitor created successfully:")
    apiResultJSON, _ := json.MarshalIndent(apiResult, "", "  ")
    fmt.Println(string(apiResultJSON))
}

Java

Java

Dependencies (Maven)

<dependencies>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.12.0</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version>
    </dependency>
</dependencies>

Example Code

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import okhttp3.*;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BareuprimeClient {
    private static final String BASE_URL = "https://api.bareuptime.co/v1";
    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
    
    private final OkHttpClient client;
    private final Gson gson;
    private final String apiKey;
    
    public BareuprimeClient(String apiKey) {
        this.apiKey = apiKey;
        this.client = new OkHttpClient();
        this.gson = new GsonBuilder().create();
    }
    
    public static class Monitor {
        private String name;
        private String url;
        private String check_interval;
        private String type;
        private String request_body;
        private String request_headers;
        
        // Constructor
        public Monitor(String name, String url, String checkInterval, String type) {
            this.name = name;
            this.url = url;
            this.check_interval = checkInterval;
            this.type = type;
        }
        
        // Getters and Setters
        public Monitor setRequestBody(String requestBody) { this.request_body = requestBody; return this; }
        public Monitor setRequestHeaders(String requestHeaders) { this.request_headers = requestHeaders; return this; }
    }
    
    public static class ApiResponse {
        private boolean success;
        private Object data;
        private ApiError error;
        
        // Getters
        public boolean isSuccess() { return success; }
        public Object getData() { return data; }
        public ApiError getError() { return error; }
    }
    
    public static class ApiError {
        private String code;
        private String message;
        
        // Getters
        public String getCode() { return code; }
        public String getMessage() { return message; }
    }
    
    public ApiResponse createMonitor(Monitor monitor) throws IOException {
        String json = gson.toJson(monitor);
        
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url(BASE_URL + "/monitors")
                .addHeader("Authorization", "Bearer " + apiKey)
                .post(body)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            String responseBody = response.body().string();
            
            if (!response.isSuccessful()) {
                throw new IOException("API Error: " + response.code() + " - " + responseBody);
            }
            
            return gson.fromJson(responseBody, ApiResponse.class);
        }
    }
    
    public ApiResponse getMonitors() throws IOException {
        Request request = new Request.Builder()
                .url(BASE_URL + "/monitors")
                .addHeader("Authorization", "Bearer " + apiKey)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            String responseBody = response.body().string();
            
            if (!response.isSuccessful()) {
                throw new IOException("API Error: " + response.code() + " - " + responseBody);
            }
            
            return gson.fromJson(responseBody, ApiResponse.class);
        }
    }
    
    public void deleteMonitor(String monitorId) throws IOException {
        Request request = new Request.Builder()
                .url(BASE_URL + "/monitors/" + monitorId)
                .addHeader("Authorization", "Bearer " + apiKey)
                .delete()
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("API Error: " + response.code() + " - " + response.body().string());
            }
        }
    }
    
    public static void main(String[] args) {
        String apiKey = System.getenv("BAREUPTIME_API_KEY");
        if (apiKey == null || apiKey.isEmpty()) {
            System.err.println("BAREUPTIME_API_KEY environment variable is required");
            System.exit(1);
        }
        
        BareuprimeClient client = new BareuprimeClient(apiKey);
        
        try {
            // Create a website monitor
            Monitor websiteMonitor = new Monitor("Company Website", "https://company.com", "5min", "get");
            
            ApiResponse result = client.createMonitor(websiteMonitor);
            System.out.println("Website monitor created successfully:");
            System.out.println(client.gson.toJson(result));
            
            // Create an API monitor with authentication
            Monitor apiMonitor = new Monitor("API Health Check", "https://api.company.com/health", "1min", "get")
                    .setRequestHeaders("Authorization: Bearer api-token-123\nX-Client: monitoring");
            
            ApiResponse apiResult = client.createMonitor(apiMonitor);
            System.out.println("API monitor created successfully:");
            System.out.println(client.gson.toJson(apiResult));
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Response Format

Success Response (201 Created)

{
  "id": 12345,
  "name": "My Website",
  "url": "https://example.com",
  "user_id": 67890,
  "type": "get",
  "timeout": 5,
  "retry_count": 3,
  "partition_key": "user_67890",
  "check_interval": "5min",
  "is_active": true,
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2024-01-15T10:30:00Z",
  "request_body": "",
  "is_public": false,
  "expired_at": null,
  "request_headers": "",
  "monitor_type": "http"
}

Error Responses

1. 400 Bad Request - Invalid request data: invalid check interval

2. 402 Payment Required - Premium feature required: Premium plan required for POST, PATCH, PUT, DELETE methods or Premium plan required for advanced monitor types or UnsupportedPlan

3. 401 Unauthorized - Invalid or missing API key: Unauthorized

Getting Help

• Documentation: https://docs.bareuptime.co
• Support: https://bareuptime.co/contact
• Report Issues: https://github.com/Bareuptime/backend/issues