API Reference Overview

# Get system information
curl http://localhost/api/info

# Start recording
curl -X POST http://localhost/api/recording/start \
  -u admin:password

# Get list of recordings
curl http://localhost/api/recordings

// Connect to WebSocket
const ws = new WebSocket('ws://localhost/api/v1');

// Send control commands
ws.onopen = () => {
    ws.send(JSON.stringify({ brightness: 75 }));
    ws.send(JSON.stringify({ record: true }));
};

// Receive state updates
ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    console.log('State update:', data);
};

# Open RTSP stream with VLC
vlc rtsp://localhost:554/stream1

# Or with FFmpeg
ffplay rtsp://localhost:554/stream1

# Or with GStreamer
gst-launch-1.0 playbin uri=rtsp://localhost:554/stream1

# Basic Authentication
curl -u username:password http://localhost/api/info

# Digest Authentication
curl --digest -u username:password http://localhost/api/info

# Bearer Token
curl -H "Authorization: Bearer <token>" http://localhost/api/info

{
    "status": "success",
    "data": {
        "key": "value"
    },
    "timestamp": 1704067200000
}

// Camera control
ws.send(JSON.stringify({ 'cam1-light': true }));
ws.send(JSON.stringify({ brightness: 75 }));
ws.send(JSON.stringify({ resolution: '1920x1080' }));

// Recording control
ws.send(JSON.stringify({ record: true }));
ws.send(JSON.stringify({ snap: true }));

// Get current state
ws.send(JSON.stringify({ 
    get: ['brightness', 'contrast', 'resolution'] 
}));

vlc rtsp://192.168.1.100:554/stream1

# Play stream
ffplay rtsp://192.168.1.100:554/stream1

# Record stream
ffmpeg -i rtsp://192.168.1.100:554/stream1 \
  -c copy output.mp4

# Transcode stream
ffmpeg -i rtsp://192.168.1.100:554/stream1 \
  -c:v libx264 -preset fast -crf 23 \
  output.mp4

gst-launch-1.0 rtspsrc location=rtsp://192.168.1.100:554/stream1 ! \
  rtph264depay ! h264parse ! avdec_h264 ! autovideosink

import cv2

cap = cv2.VideoCapture('rtsp://192.168.1.100:554/stream1')

while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow('RTSP Stream', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

// Get WebRTC offer from server
const response = await fetch('/api/webrtc/offer');
const offer = await response.json();

// Create peer connection
const pc = new RTCPeerConnection({
    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
});

// Set remote description
await pc.setRemoteDescription(offer);

// Create answer
const answer = await pc.createAnswer();
await pc.setLocalDescription(answer);

// Send answer to server
await fetch('/api/webrtc/answer', {
    method: 'POST',
    body: JSON.stringify(answer)
});

// Handle incoming video track
pc.ontrack = (event) => {
    document.getElementById('video').srcObject = event.streams[0];
};

from onvif import ONVIFCamera

# Create ONVIF camera instance
cam = ONVIFCamera(
    '192.168.1.100',
    80,
    'admin',
    'password'
)

# Get device information
device_info = cam.devicemgmt.GetDeviceInformation()
print(f"Manufacturer: {device_info.Manufacturer}")
print(f"Model: {device_info.Model}")

# Get media profiles
media = cam.create_media_service()
profiles = media.GetProfiles()

for profile in profiles:
    print(f"Profile: {profile.Name}")
    print(f"Resolution: {profile.VideoEncoderConfiguration.Resolution}")

// Good: Use HTTPS/WSS in production
const ws = new WebSocket('wss://camera.example.com/api/v1');

// Bad: Plain HTTP/WS in production
const ws = new WebSocket('ws://camera.example.com/api/v1');

// Good: Store tokens securely
const token = sessionStorage.getItem('authToken');

// Bad: Hardcode credentials
const password = 'admin123';

{
    "error": "Rate limit exceeded",
    "limit": 100,
    "period": "minute",
    "retry_after": 45
}

ws.onerror = (error) => {
    console.error('WebSocket error:', error);
    // Implement reconnection logic
};

ws.onclose = (event) => {
    if (event.code === 1000) {
        // Normal closure
    } else if (event.code === 1006) {
        // Abnormal closure - reconnect
        setTimeout(() => connectWebSocket(), 5000);
    }
};

// Batch operations
await Promise.all([
    fetch('/api/settings/brightness', { method: 'POST', body: '75' }),
    fetch('/api/settings/contrast', { method: 'POST', body: '60' })
]);

// Sequential requests
await fetch('/api/settings/brightness', { method: 'POST', body: '75' });
await fetch('/api/settings/contrast', { method: 'POST', body: '60' });

// Batch state updates
ws.send(JSON.stringify({
    brightness: 75,
    contrast: 60,
    saturation: 50
}));

// Multiple separate messages
ws.send(JSON.stringify({ brightness: 75 }));
ws.send(JSON.stringify({ contrast: 60 }));
ws.send(JSON.stringify({ saturation: 50 }));

# Use appropriate transport
rtsp://host/stream1?tcp  # TCP for reliable delivery
rtsp://host/stream1?udp  # UDP for lower latency

# Request lower resolution if needed
rtsp://host/stream2  # Secondary stream (lower resolution)

# Using curl
curl -v http://localhost/api/info

# Using httpie
http GET http://localhost/api/info

# Using Postman
# Import our Postman collection from docs/api/postman/

# Using websocat
websocat ws://localhost/api/v1

# Using wscat
wscat -c ws://localhost/api/v1

# Using VLC
vlc rtsp://localhost:554/stream1

# Using FFprobe
ffprobe rtsp://localhost:554/stream1

import requests
import websockets
import asyncio

def test_http_api():
    response = requests.get('http://localhost/api/info')
    assert response.status_code == 200
    assert 'version' in response.json()

async def test_websocket_api():
    async with websockets.connect('ws://localhost/api/v1') as ws:
        await ws.send('{"get": ["brightness"]}')
        response = await ws.recv()
        assert 'brightness' in response

# Run tests
test_http_api()
asyncio.run(test_websocket_api())

// Use WebSocket for real-time control
const ws = new WebSocket('wss://camera.local/api/v1');

// Use WebRTC for video display
const video = document.getElementById('video');
const pc = new RTCPeerConnection();
// ... WebRTC setup

// Use HTTP for file downloads
fetch('/api/recordings')
    .then(r => r.json())
    .then(recordings => displayRecordings(recordings));

// Android example
// WebSocket for control
val ws = WebSocket("wss://camera.local/api/v1")

// ExoPlayer for RTSP video
val player = ExoPlayer.Builder(context).build()
player.setMediaItem(MediaItem.fromUri("rtsp://camera.local:554/stream1"))

// Retrofit for HTTP API
interface CameraApi {
    @GET("/api/recordings")
    suspend fun getRecordings(): List<Recording>
}

# ONVIF for device management
from onvif import ONVIFCamera

camera = ONVIFCamera('192.168.1.100', 80, 'admin', 'pass')
profiles = camera.create_media_service().GetProfiles()

# RTSP for video recording
ffmpeg -i rtsp://192.168.1.100:554/stream1 \
    -c copy -f segment -segment_time 300 \
    recording_%03d.mp4

#!/bin/bash
# Start recording at specific time

# Authenticate
TOKEN=$(curl -s -X POST http://camera.local/api/login \
    -d '{"username":"admin","password":"pass"}' | jq -r .token)

# Start recording
curl -X POST http://camera.local/api/recording/start \
    -H "Authorization: Bearer $TOKEN"

# Wait 1 hour
sleep 3600

# Stop recording
curl -X POST http://camera.local/api/recording/stop \
    -H "Authorization: Bearer $TOKEN"

# Check if server is running
curl http://localhost/api/status

# Check firewall
sudo ufw status
sudo ufw allow 80/tcp
sudo ufw allow 554/tcp

# Verify credentials
curl -u admin:password http://localhost/api/info

# Check user permissions
curl http://localhost/api/users/admin/permissions

# Test RTSP endpoint
ffprobe rtsp://localhost:554/stream1

# Check camera status
curl http://localhost/api/camera/status

# Verify stream is active
curl http://localhost/api/streams