> ## Documentation index
> Fetch the complete documentation index at: https://developer.rhombus.com/llms.txt
> Use it to discover all available pages before exploring further.

# Alarm Monitoring

> Build alarm monitoring integrations with the Rhombus API — track locations, dispatch responders, and manage threat cases and security alerts in real time.

## Overview

Rhombus alarm monitoring provides centralized security management for your locations. Through the API, you can enable or disable monitoring per location, respond to threat cases in real time, manage keypad PINs, and retrieve policy alerts. This is especially useful for building custom security dashboards, automating alarm response workflows, or integrating Rhombus alarms into a third-party monitoring platform.

When monitoring is enabled for a location, Rhombus cameras and sensors detect security events and generate threat cases. Your application can then retrieve, escalate, dismiss, or cancel those threat cases programmatically.

## Prerequisites

> **Note**: Before you begin, make sure you have:
>
> - A **Rhombus API key** with alarm monitoring permissions (generated in the [Rhombus Console](https://console.rhombussystems.com/settings/integrations/api-tokens/) under **Settings → Integrations & Developer Resources → API Tokens**)
> - An **alarm monitoring license** active on your organization
> - At least one **configured location** with cameras or sensors enrolled in alarm monitoring

## Check monitoring status

Use the org-wide status endpoint to see which locations have monitoring enabled, or query a specific location directly.

### Organization-wide status

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/orgStatus",
    headers=headers,
    json={}
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/orgStatus', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({})
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/orgStatus \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{}'
```

### Location-specific status

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/locationStatus",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/locationStatus', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/locationStatus \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"locationUuid": "YOUR_LOCATION_UUID"}'
```

You can also retrieve the full alarm monitoring settings for a location, including armed state and configured schedules:

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/getAlertMonitoringSettingsForLocation",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/getAlertMonitoringSettingsForLocation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/getAlertMonitoringSettingsForLocation \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"locationUuid": "YOUR_LOCATION_UUID"}'
```

## Enable and disable monitoring

Toggle alarm monitoring on or off for a specific location. When you enable monitoring, the system begins watching for security events at that location. When you disable it, threat case generation pauses.

### Enable monitoring

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/enableMonitoringForLocation",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/enableMonitoringForLocation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/enableMonitoringForLocation \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"locationUuid": "YOUR_LOCATION_UUID"}'
```

### Disable monitoring

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/disableMonitoringForLocation",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/disableMonitoringForLocation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/disableMonitoringForLocation \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"locationUuid": "YOUR_LOCATION_UUID"}'
```

> **Tip**: You can automate monitoring schedules by enabling and disabling monitoring at specific times using a cron job or scheduler in your application.

## Manage threat cases

Threat cases represent detected security events that require a response. When a camera or sensor detects suspicious activity at a monitored location, the system creates a threat case. You can then retrieve, escalate, dismiss, or cancel these cases through the API.

### Get threat cases

Retrieve threat cases within a time range. Use pagination parameters to handle large result sets.

```python Python
import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

# Get threat cases from the last 24 hours
now_ms = int(time.time() * 1000)
one_day_ago_ms = now_ms - (24 * 60 * 60 * 1000)

response = requests.post(
    "https://api2.rhombussystems.com/api/event/getAlertMonitoringThreatCases",
    headers=headers,
    json={
        "afterTimestampMs": one_day_ago_ms,
        "beforeTimestampMs": now_ms
    }
)
data = response.json()

for case in data.get("threatCases", []):
    print(f"Threat Case: {case['uuid']} - Status: {case['status']}")
```

```javascript JavaScript
const now = Date.now();
const oneDayAgo = now - (24 * 60 * 60 * 1000);

const response = await fetch('https://api2.rhombussystems.com/api/event/getAlertMonitoringThreatCases', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    afterTimestampMs: oneDayAgo,
    beforeTimestampMs: now
  })
});
const data = await response.json();

for (const threatCase of data.threatCases || []) {
  console.log(`Threat Case: ${threatCase.uuid} - Status: ${threatCase.status}`);
}
```

```bash cURL
# Replace timestamps with current epoch millisecond values
curl -X POST https://api2.rhombussystems.com/api/event/getAlertMonitoringThreatCases \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "afterTimestampMs": 1712620800000,
    "beforeTimestampMs": 1712707200000
  }'
```

### Respond to threat cases

When a threat case is active, you have three response options depending on the situation.

**Escalate to Alarm**

Escalate a threat case to a full alarm when the threat is confirmed and requires immediate response from security or law enforcement.

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/escalateThreatCaseToAlarm",
    headers=headers,
    json={
        "uuid": "YOUR_THREAT_CASE_ID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/escalateThreatCaseToAlarm', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    uuid: 'YOUR_THREAT_CASE_ID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/escalateThreatCaseToAlarm \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"uuid": "YOUR_THREAT_CASE_ID"}'
```

**Dismiss**

Dismiss a threat case when you have reviewed it and determined it does not require action (for example, a false positive).

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/dismissThreatCase",
    headers=headers,
    json={
        "uuid": "YOUR_THREAT_CASE_ID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/dismissThreatCase', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    uuid: 'YOUR_THREAT_CASE_ID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/dismissThreatCase \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"uuid": "YOUR_THREAT_CASE_ID"}'
```

**Cancel**

Cancel a threat case to stop it from progressing further. Use this when the situation has been resolved before escalation is needed.

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/cancelThreatCase",
    headers=headers,
    json={
        "uuid": "YOUR_THREAT_CASE_ID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/cancelThreatCase', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    uuid: 'YOUR_THREAT_CASE_ID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/cancelThreatCase \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"uuid": "YOUR_THREAT_CASE_ID"}'
```

## Manage location PINs

PINs allow users to arm and disarm alarm monitoring at a location using a Rhombus keypad. You can create and delete PINs for each location through the API.

### Create a PIN

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/createCustomPinForLocation",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID",
        "pin": "4829",
        "name": "Front Desk Staff"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/createCustomPinForLocation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID',
    pin: '4829',
    name: 'Front Desk Staff'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/createCustomPinForLocation \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "locationUuid": "YOUR_LOCATION_UUID",
    "pin": "4829",
    "name": "Front Desk Staff"
  }'
```

### Delete a PIN

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/alertmonitoring/deletePinForLocation",
    headers=headers,
    json={
        "locationUuid": "YOUR_LOCATION_UUID",
        "pin": "4829"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/alertmonitoring/deletePinForLocation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    locationUuid: 'YOUR_LOCATION_UUID',
    pin: '4829'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/alertmonitoring/deletePinForLocation \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "locationUuid": "YOUR_LOCATION_UUID",
    "pin": "4829"
  }'
```

> **Warning**: Deleting a PIN takes effect immediately. Make sure the PIN is no longer needed before removing it, as users relying on that PIN will lose the ability to arm or disarm the system at the keypad.

## Work with policy alerts

Policy alerts are triggered when configured detection policies (such as motion detection or person detection) fire at monitored locations. Use these endpoints to retrieve recent alerts and dismiss them after review.

### Get policy alerts

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/event/getPolicyAlerts",
    headers=headers,
    json={}
)
data = response.json()

for alert in data.get("policyAlerts", []):
    print(f"Alert: {alert['uuid']} - Type: {alert.get('type', 'N/A')}")
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/event/getPolicyAlerts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({})
});
const data = await response.json();

for (const alert of data.policyAlerts || []) {
  console.log(`Alert: ${alert.uuid} - Type: ${alert.type || 'N/A'}`);
}
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/event/getPolicyAlerts \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{}'
```

### Dismiss a policy alert

```python Python
import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/event/dismissPolicyAlertV2",
    headers=headers,
    json={
        "alertUuid": "YOUR_POLICY_ALERT_UUID"
    }
)
print(response.json())
```

```javascript JavaScript
const response = await fetch('https://api2.rhombussystems.com/api/event/dismissPolicyAlertV2', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    alertUuid: 'YOUR_POLICY_ALERT_UUID'
  })
});
const data = await response.json();
console.log(data);
```

```bash cURL
curl -X POST https://api2.rhombussystems.com/api/event/dismissPolicyAlertV2 \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"alertUuid": "YOUR_POLICY_ALERT_UUID"}'
```

## Next steps

- **[Webhook Notifications](https://developer.rhombus.com/webhooks)**: Receive real-time notifications when alarm events occur so your application can respond immediately
- **[API Reference](https://developer.rhombus.com/api-reference/alert-monitoring-webservice/get-organization-status)**: Explore the full API reference for complete request and response schemas for all alarm monitoring endpoints