Development Resources

This guide provides developers with comprehensive resources for building integrations and custom solutions with PulseGuard.

Getting Started

Prerequisites

Valid PulseGuard account with Expert Plan for API access
API token generated from your dashboard
Basic understanding of REST APIs and HTTP requests

Authentication

All API requests require authentication using a Bearer token:

curl -H "Authorization: Bearer YOUR_API_TOKEN" \
  https://api.ipulse.one/domains

Quick Start Examples

Domain Monitoring

Create a Domain Monitor

const response = await fetch('https://api.ipulse.one/domains', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'My Website',
    url: 'https://example.com',
    check_interval: 5
  })
});

const domain = await response.json();
console.log('Created domain:', domain.data);

Get Domain Statistics

import requests

response = requests.get(
    'https://api.ipulse.one/stats/domains/DOMAIN-UUID/response-time/stats',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'},
    params={'period': '24h'}
)

stats = response.json()
print(f"Average response time: {stats['data']['average_response_time']}ms")
print(f"Uptime percentage: {stats['data']['uptime_percentage']}%")

PHP Domain Management

<?php
$client = new \GuzzleHttp\Client();

$response = $client->get('https://api.ipulse.one/domains', [
    'headers' => [
        'Authorization' => 'Bearer ' . $apiToken,
        'Accept' => 'application/json'
    ]
]);

$domains = json_decode($response->getBody(), true);
foreach ($domains['data'] as $domain) {
    echo "Domain: {$domain['name']} - Status: {$domain['status']}\n";
}
?>

Device Management

Register a Device

curl -X POST https://api.ipulse.one/devices \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production Server",
    "hostname": "server01.example.com",
    "description": "Main production server"
  }'

Get Device Metrics

const getDeviceMetrics = async (deviceUuid) => {
  const response = await fetch(`https://api.ipulse.one/devices/${deviceUuid}`, {
    headers: {
      'Authorization': 'Bearer YOUR_API_TOKEN'
    }
  });
  
  const device = await response.json();
  return {
    status: device.data.status,
    cpu: device.data.metrics?.cpu_usage,
    memory: device.data.metrics?.memory_usage,
    disk: device.data.metrics?.disk_usage
  };
};

Service Monitoring

Create HTTP Service Monitor

import requests

service_data = {
    "name": "API Health Check",
    "type": "http",
    "url": "https://api.example.com/health",
    "check_interval": 5,
    "timeout": 30
}

response = requests.post(
    'https://api.ipulse.one/services',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'},
    json=service_data
)

service = response.json()
print(f"Created service monitor: {service['data']['uuid']}")

Manual Service Check

curl -X POST https://api.ipulse.one/services/SERVICE-UUID/check \
  -H "Authorization: Bearer YOUR_API_TOKEN"

Toolbox Utilities

DNS Lookup

const dnsLookup = async (domain, recordType = 'A') => {
  const response = await fetch('https://api.ipulse.one/toolbox/dns-lookup', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_TOKEN',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      domain: domain,
      record_type: recordType
    })
  });
  
  return await response.json();
};

// Usage
const result = await dnsLookup('example.com', 'MX');
console.log('DNS records:', result.data.records);

DNS Lookup (Python)

import requests

response = requests.post(
    'https://api.ipulse.one/toolbox/dns-lookup',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'},
    json={'domain': 'example.com', 'record_type': 'A'}
)

dns_records = response.json()
print(f"DNS Records: {dns_records}")

Port Scanning

curl -X POST https://api.ipulse.one/toolbox/port-scan \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "host": "example.com",
    "ports": "80,443,22-25"
  }'

Chat Conversations

PulseGuard ondersteunt chat conversaties voor AI integratie:

// Save a conversation
const saveConversation = async (conversationData) => {
  const response = await fetch('https://api.ipulse.one/chat/conversations', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_TOKEN',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(conversationData)
  });

  return await response.json();
};

Advanced Integration Patterns

Webhook Integration

Set up webhooks to receive real-time notifications:

// Express.js webhook handler
app.post('/pulseguard-webhook', (req, res) => {
  const event = req.body;
  
  switch (event.type) {
    case 'domain.down':
      console.log(`Alert: ${event.data.domain} is down!`);
      // Send Slack notification, SMS, etc.
      break;
    case 'anomaly.detected':
      console.log(`Anomaly detected on ${event.data.domain}`);
      // Trigger automated investigation
      break;
  }
  
  res.status(200).send('OK');
});

Batch Operations

Efficiently manage multiple resources:

import asyncio
import aiohttp

async def batch_check_domains(domains):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for domain_uuid in domains:
            task = check_domain_status(session, domain_uuid)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        return results

async def check_domain_status(session, domain_uuid):
    async with session.get(
        f'https://api.ipulse.one/domains/{domain_uuid}',
        headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
    ) as response:
        data = await response.json()
        return {
            'uuid': domain_uuid,
            'status': data['data']['status'],
            'response_time': data['data']['response_time']
        }

Error Handling & Retry Logic

import time
import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_api_client():
    session = requests.Session()
    
    # Configure retry strategy
    retry_strategy = Retry(
        total=3,
        status_forcelist=[429, 500, 502, 503, 504],
        method_whitelist=["HEAD", "GET", "OPTIONS"],
        backoff_factor=1
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    session.headers.update({
        'Authorization': 'Bearer YOUR_API_TOKEN',
        'Content-Type': 'application/json',
        'User-Agent': 'MyApp/1.0'
    })
    
    return session

# Usage with proper error handling
def safe_api_call(client, url):
    try:
        response = client.get(url, timeout=30)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print("Authentication failed. Check your API token.")
        elif e.response.status_code == 403:
            print("Access denied. Expert Plan required.")
        else:
            print(f"HTTP error: {e}")
    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
    
    return None

Migration Guide

Migrating from Legacy API (v2)

The legacy v2 endpoints are deprecated. Here’s how to migrate:

Domain Endpoints

- GET /api/v2/domains
+ GET /api/v2/domains

- POST /api/v2/domains
+ POST /api/v2/domains

- GET /api/v2/domains/{uuid}
+ GET /api/v2/domains/{uuid}

Service Monitor Endpoints

- GET /api/v2/service-monitors
+ GET /api/v2/services

- POST /api/v2/service-monitors
+ POST /api/v2/services

Device Management Endpoints

- GET /api/v2/device-monitoring
+ GET /api/v2/devices

- POST /api/v2/device-monitoring
+ POST /api/v2/devices

Breaking Changes in v2.0

Response format standardization
Enhanced authentication requirements
New rate limiting policies
Deprecated fields removal

Best Practices

Security

Store API tokens securely - Use environment variables or secure key management
Validate SSL certificates - Always verify HTTPS connections
Implement proper error handling - Don’t expose sensitive information in logs
Use HTTPS only - Never send API tokens over unencrypted connections

Performance

Implement caching - Cache frequently accessed data locally
Use pagination - For large datasets, use page parameters
Batch requests - Combine multiple operations when possible
Respect rate limits - Implement exponential backoff

Monitoring

Log API usage - Track your integration’s API calls
Monitor response times - Set up alerts for slow API responses
Health checks - Regularly verify your integration is working
Version tracking - Stay updated with API changes

SDKs & Libraries

Official SDKs (Coming Soon)

PHP SDK with Laravel integration
Python SDK with async support
Node.js SDK with TypeScript
Go SDK for high-performance applications

Community Libraries

Check our GitHub organization for community-maintained libraries and examples.

Support & Resources

API Documentation: Interactive playground available in this documentation
Status Page: status.ipulse.one
GitHub Issues: Report bugs and feature requests
Email Support: info@ipulse.one
Discord Community: Join our developer community

Rate Limits

Plan	Requests/Minute	Requests/Hour	Requests/Day
Expert	1,000	10,000	100,000
Pro	300	3,000	30,000
Free	100	1,000	10,000

Rate limit headers are included in all responses:

X-RateLimit-Limit: Request limit per window
X-RateLimit-Remaining: Remaining requests in current window
X-RateLimit-Reset: Time when the rate limit resets

Need help getting started? Contact our support team at info@pulseguard.nl

​Development Resources

​Getting Started

​Prerequisites

​Authentication

​Quick Start Examples

​Domain Monitoring

​Create a Domain Monitor

​Get Domain Statistics

​PHP Domain Management

​Device Management

​Register a Device

​Get Device Metrics

​Service Monitoring

​Create HTTP Service Monitor

​Manual Service Check

​Toolbox Utilities

​DNS Lookup

​DNS Lookup (Python)

​Port Scanning

​Chat Conversations

​Advanced Integration Patterns

​Webhook Integration

​Batch Operations

​Error Handling & Retry Logic

​Migration Guide

​Migrating from Legacy API (v2)

​Domain Endpoints

​Service Monitor Endpoints

​Device Management Endpoints

​Breaking Changes in v2.0

​Best Practices

​Security

​Performance

​Monitoring

​SDKs & Libraries

​Official SDKs (Coming Soon)

​Community Libraries

​Support & Resources

​Rate Limits