API Code Examples

Ready-to-use examples for common API operations.

JavaScript/Node.js

Basic Setup

const API_KEY = process.env.UPSTAT_API_KEY;
const BASE_URL = 'https://api.upstat.io/v1';

async function apiRequest(endpoint, options = {}) {
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    throw new Error(`API Error: ${response.statusText}`);
  }

  return response.json();
}

Create a Monitor

async function createMonitor() {
  const monitor = await apiRequest('/monitors', {
    method: 'POST',
    body: JSON.stringify({
      name: 'Production API',
      url: 'https://api.example.com/health',
      type: 'http',
      interval: 60,
      regions: ['us-east-1', 'eu-west-1'],
      alertAfter: 2
    })
  });

  console.log('Monitor created:', monitor.data.uuid);
}

Create an Incident

async function createIncident(title, severity = 'P3') {
  const incident = await apiRequest('/incidents', {
    method: 'POST',
    body: JSON.stringify({
      title,
      severity,
      description: 'Automated incident creation',
      status: 'open'
    })
  });

  return incident.data;
}

![Placeholder: Code Example Running in Terminal]

Python

Basic Setup

import os
import requests
from typing import Dict, Any

API_KEY = os.environ.get('UPSTAT_API_KEY')
BASE_URL = 'https://api.upstat.io/v1'

def api_request(endpoint: str, method: str = 'GET', 
                data: Dict[str, Any] = None) -> Dict:
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }
    
    response = requests.request(
        method=method,
        url=f'{BASE_URL}{endpoint}',
        headers=headers,
        json=data
    )
    
    response.raise_for_status()
    return response.json()

List All Monitors

def list_monitors():
    monitors = api_request('/monitors')
    
    for monitor in monitors['data']:
        status = '✅' if monitor['status'] == 'up' else '❌'
        print(f"{status} {monitor['name']} - {monitor['url']}")

Update Incident Status

def resolve_incident(incident_uuid: str, resolution: str):
    return api_request(
        f'/incidents/{incident_uuid}',
        method='PUT',
        data={
            'status': 'resolved',
            'resolution': resolution
        }
    )

Ruby

Basic Client

require 'net/http'
require 'json'
require 'uri'

class UpstatClient
  BASE_URL = 'https://api.upstat.io/v1'
  
  def initialize(api_key)
    @api_key = api_key
  end
  
  def request(endpoint, method = :get, data = nil)
    uri = URI("#{BASE_URL}#{endpoint}")
    
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = case method
    when :post then Net::HTTP::Post.new(uri)
    when :put then Net::HTTP::Put.new(uri)
    when :delete then Net::HTTP::Delete.new(uri)
    else Net::HTTP::Get.new(uri)
    end
    
    request['Authorization'] = "Bearer #{@api_key}"
    request['Content-Type'] = 'application/json'
    request.body = data.to_json if data
    
    response = http.request(request)
    JSON.parse(response.body)
  end
end

Create Status Page Update

client = UpstatClient.new(ENV['UPSTAT_API_KEY'])

# Update component status
update = client.request(
  '/status-pages/abc123/components/xyz789',
  :put,
  {
    status: 'partial_outage',
    message: 'Investigating database performance issues'
  }
)

puts "Status updated: #{update['status']}"

Go

HTTP Client

package main

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

type Client struct {
    APIKey  string
    BaseURL string
}

func NewClient() *Client {
    return &Client{
        APIKey:  os.Getenv("UPSTAT_API_KEY"),
        BaseURL: "https://api.upstat.io/v1",
    }
}

func (c *Client) Request(method, endpoint string, 
                        payload interface{}) (map[string]interface{}, error) {
    var body []byte
    var err error
    
    if payload != nil {
        body, err = json.Marshal(payload)
        if err != nil {
            return nil, err
        }
    }
    
    req, err := http.NewRequest(method, c.BaseURL+endpoint, 
                               bytes.NewBuffer(body))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

Monitor Health Check

func checkMonitorHealth(client *Client, monitorUUID string) {
    result, err := client.Request("GET", 
                                 fmt.Sprintf("/monitors/%s", monitorUUID), 
                                 nil)
    if err != nil {
        log.Fatal(err)
    }
    
    monitor := result["data"].(map[string]interface{})
    fmt.Printf("Monitor: %s\n", monitor["name"])
    fmt.Printf("Status: %s\n", monitor["status"])
    fmt.Printf("Response Time: %vms\n", monitor["responseTime"])
}

![Placeholder: Multiple Code Examples in Different Languages]

Webhooks Handler

Express.js Webhook Receiver

const express = require('express');
const crypto = require('crypto');

const app = express();
app.use(express.json());

const WEBHOOK_SECRET = process.env.UPSTAT_WEBHOOK_SECRET;

// Verify webhook signature
function verifySignature(payload, signature) {
  const hash = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(JSON.stringify(payload))
    .digest('hex');
    
  return `sha256=${hash}` === signature;
}

// Handle incoming webhooks
app.post('/webhooks/upstat', (req, res) => {
  const signature = req.headers['x-upstat-signature'];
  
  if (!verifySignature(req.body, signature)) {
    return res.status(401).send('Invalid signature');
  }
  
  const { event, data } = req.body;
  
  switch (event) {
    case 'incident.created':
      console.log(`New incident: ${data.title}`);
      // Trigger your incident response workflow
      break;
      
    case 'monitor.down':
      console.log(`Monitor down: ${data.name}`);
      // Alert your team
      break;
      
    case 'monitor.recovered':
      console.log(`Monitor recovered: ${data.name}`);
      // Update status page
      break;
  }
  
  res.status(200).send('OK');
});

Common Patterns

Pagination Helper

async function getAllMonitors() {
  const monitors = [];
  let page = 1;
  let hasMore = true;
  
  while (hasMore) {
    const response = await apiRequest(`/monitors?page=${page}&limit=100`);
    monitors.push(...response.data);
    
    hasMore = response.pagination.page < response.pagination.pages;
    page++;
  }
  
  return monitors;
}

Error Handling

async function safeApiCall(fn) {
  try {
    return await fn();
  } catch (error) {
    if (error.response?.status === 429) {
      // Rate limited - wait and retry
      const retryAfter = error.response.headers['retry-after'] || 60;
      console.log(`Rate limited. Retrying in ${retryAfter}s...`);
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      return safeApiCall(fn);
    }
    
    throw error;
  }
}

---

Learn more

• API overview
• Authentication
• API endpoints