> ## Documentation Index
> Fetch the complete documentation index at: https://api-docs.rhombus.community/llms.txt
> Use this file 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 under Settings > API)
  * An **alarm monitoring license** active on your organization
  * At least one **configured location** with cameras or sensors enrolled in alarm monitoring
</Note>

## 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

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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 '{}'
  ```
</CodeGroup>

### Location-Specific Status

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"}'
  ```
</CodeGroup>

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

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"}'
  ```
</CodeGroup>

## 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

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"}'
  ```
</CodeGroup>

### Disable Monitoring

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"}'
  ```
</CodeGroup>

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

## 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.

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  # 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
    }'
  ```
</CodeGroup>

### Respond to Threat Cases

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

<Tabs>
  <Tab title="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.

    <CodeGroup>
      ```python Python theme={null}
      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 theme={null}
      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 theme={null}
      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"}'
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Dismiss">
    Dismiss a threat case when you have reviewed it and determined it does not require action (for example, a false positive).

    <CodeGroup>
      ```python Python theme={null}
      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 theme={null}
      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 theme={null}
      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"}'
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Cancel">
    Cancel a threat case to stop it from progressing further. Use this when the situation has been resolved before escalation is needed.

    <CodeGroup>
      ```python Python theme={null}
      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 theme={null}
      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 theme={null}
      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"}'
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## 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

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"
    }'
  ```
</CodeGroup>

### Delete a PIN

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"
    }'
  ```
</CodeGroup>

<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.
</Warning>

## 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

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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 '{}'
  ```
</CodeGroup>

### Dismiss a Policy Alert

<CodeGroup>
  ```python Python theme={null}
  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 theme={null}
  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 theme={null}
  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"}'
  ```
</CodeGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Webhook Notifications" icon="webhook" href="/webhooks">
    Receive real-time notifications when alarm events occur so your application can respond immediately
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference">
    Explore the full API reference for complete request and response schemas for all alarm monitoring endpoints
  </Card>
</CardGroup>