Domotz Public API v1.12.5

The Domotz Public API

Use the "API Key Endpoint" which you can retrieve from the Domotz Portal as the Base URL for your API calls.

The Domotz Public API uses standard HTTP response codes, authentication, and verbs. JSON format is used in responses and accepted for request bodies. All date-time formats are expressed as yyyy-mm-ddThh:mm:ss. Date-time must be expressed in UTC. Specification of different TimeZones are not allowed.

Domotz Webhook

It is possible to subscribe to events happening on the Domotz platform, both at an Agent level and Device level, through the usage of Webhooks.

Please refer to the user-guide on the usage of the Webhook as a possible contact channel to receive notification of events and how to create a Shared Alert Profile. Moreover, refer to getAlertProfiles, bindAlertProfileToAgent and bindAlertProfileToDevice on how to retrieve the list of Shared Alert Profiles and bind to Agents and Devices respectively. In those same sections you also have the list of all the possible Webhook events and references to the Schemas.

Authentication

API Key (api_key)
- Parameter Name: X-Api-Key, in: header. Get you API Key from the Domotz Portal or contact us

agent

listAgents

curl -X GET {baseURL}/public-api/v1/agent \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent

Returns the agents list

Curl

curl -X GET {baseURL}/public-api/v1/agent \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 100. Default value is 10
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
display_name	query	string	false	Consider only agents with `display_name` containing the string (case insensitive)
team_name	query	string	false	Filters by team name (companies only)

[
  {
    "access_right": {
      "api_enabled": true,
      "granting_user": {
        "name": "user@example.com"
      },
      "status": "OWNED"
    },
    "creation_time": "2019-08-24T14:15:22Z",
    "display_name": "string",
    "id": 0,
    "installation_info": {
      "contract_id": "string",
      "customer_id": "string"
    },
    "licence": {
      "activation_time": "2019-08-24T14:15:22Z",
      "bound_mac_address": "string",
      "code": "string",
      "expiration_time": "2019-08-24T14:15:22Z",
      "id": 0
    },
    "location": {
      "latitude": "string",
      "longitude": "string"
    },
    "organization": {
      "id": 0,
      "name": "string"
    },
    "status": {
      "last_change": "2019-08-24T14:15:22Z",
      "value": "ONLINE"
    },
    "team": {
      "area": {
        "id": 0
      },
      "id": 0,
      "leader_id": 0,
      "name": "string"
    },
    "timezone": "string",
    "version": {
      "agent": "string",
      "package": "string"
    },
    "wan_info": {
      "hostname": "string",
      "ip": "string"
    }
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The agent list	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentBase]	false	none
» access_right	object	false	none
»» api_enabled	boolean	false	If `false` the agent plan doesn't allow for API access: you only can see this agent in the list
»» granting_user	object	false	none
»»» name	string(email)	false	none
»» status	string	false	OWNED: you own this agent PROPOSED: the owner proposed you to access the agent, you can accept or reject the offer GRANTED: you accepted the collaboration request for this agent ASSIGNED: your team leader has given you access to the agent
» creation_time	string(date-time)	false	none
» display_name	string	true	none
» id	integer(int32)	true	none
» installation_info	object	false	none
»» contract_id	string	false	none
»» customer_id	string	false	none
» licence	object	false	none
»» activation_time	string(date-time)	false	none
»» bound_mac_address	string	false	The MAC address of the primary interface of the device the software agent runs on
»» code	string	false	none
»» expiration_time	string(date-time)	false	none
»» id	integer(int32)	false	none
» location	object	false	none
»» latitude	string	false	none
»» longitude	string	false	none
» organization	object	false	none
»» id	integer(int32)	false	none
»» name	string	false	none
» status	object	false	none
»» last_change	string(date-time)	false	none
»» value	string	false	none
» team	object	false	The Team and Company Area information, only available for companies
»» area	object	false	none
»»» id	integer(int32)	false	none
»» id	integer(int32)	false	none
»» leader_id	integer(int32)	false	none
»» name	string	false	none
» timezone	string	false	none
» version	object	false	none
»» agent	string	false	none
»» package	string	false	none
» wan_info	object	false	none
»» hostname	string	false	none
»» ip	string	false	none

Enumerated Values

Property	Value
status	OWNED
status	GRANTED
status	PROPOSED
status	ASSIGNED
value	ONLINE
value	OFFLINE

countAgents

curl -X HEAD {baseURL}/public-api/v1/agent \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent

Counts the agents

Curl

curl -X HEAD {baseURL}/public-api/v1/agent \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
display_name	query	string	false	Consider only agents with `display_name` containing the string (case insensitive)
team_name	query	string	false	Filters by team name (companies only)

Responses

Status	Meaning	Description	Schema
204	No Content	The number of agents matching the filtering criteria	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	The number of agents matching the filtering criteria

deleteAgent

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}

Deletes an agent

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getAgent

curl -X GET {baseURL}/public-api/v1/agent/{agent_id} \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}

Returns the details of an agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id} \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "access_right": {
    "api_enabled": true,
    "granting_user": {
      "name": "user@example.com"
    },
    "status": "OWNED"
  },
  "creation_time": "2019-08-24T14:15:22Z",
  "display_name": "string",
  "id": 0,
  "installation_info": {
    "contract_id": "string",
    "customer_id": "string"
  },
  "licence": {
    "activation_time": "2019-08-24T14:15:22Z",
    "bound_mac_address": "string",
    "code": "string",
    "expiration_time": "2019-08-24T14:15:22Z",
    "id": 0
  },
  "location": {
    "latitude": "string",
    "longitude": "string"
  },
  "organization": {
    "id": 0,
    "name": "string"
  },
  "status": {
    "last_change": "2019-08-24T14:15:22Z",
    "value": "ONLINE"
  },
  "team": {
    "area": {
      "id": 0
    },
    "id": 0,
    "leader_id": 0,
    "name": "string"
  },
  "timezone": "string",
  "version": {
    "agent": "string",
    "package": "string"
  },
  "wan_info": {
    "hostname": "string",
    "ip": "string"
  },
  "listen_on": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	The agent	AgentDetail

getConnectionConsumption

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/connection/consumption \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/connection/consumption',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/connection/consumption',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/connection/consumption', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/connection/consumption',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/connection/consumption", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/connection/consumption

Get the connection consumption on the given agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/connection/consumption \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "current": 0,
  "limit": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	none	ConnectionConsumption

getAgentVPNActiveConnections

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/connection/vpn-session

Get the Active VPN connections for the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "bytes": 0,
    "creation_time": "2019-08-24T14:15:22Z",
    "expiration_time": "2019-08-24T14:15:22Z",
    "id": 0,
    "name": "string",
    "status": "ACTIVE"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Agent VPN Connection information	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentVPNActiveConnection]	false	none
» bytes	integer(int32)	true	Current VPN connection consumption (bytes)
» creation_time	string(date-time)	true	none
» expiration_time	string(date-time)	true	none
» id	integer(int32)	true	The ID of the VPN connection
» name	string	true	The user that started the VPN connection
» status	string	true	The status of the vpn connection

Enumerated Values

Property	Value
status	ACTIVE
status	INACTIVE
status	EXPIRED

metrics

getAgentListUptime

curl -X GET {baseURL}/public-api/v1/agent/uptime \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/uptime',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/uptime',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/uptime', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/uptime',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/uptime", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/uptime

Returns the uptime of all agents

Curl

curl -X GET {baseURL}/public-api/v1/agent/uptime \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "agent_id": 0,
    "downtime_intervals": [
      {
        "end": "2019-08-24T14:15:22Z",
        "start": "2019-08-24T14:15:22Z"
      }
    ],
    "online_seconds": 0,
    "total_seconds": 0,
    "uptime": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The uptime of the agents	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentUptime]	false	none
» agent_id	integer(int32)	true	none
» downtime_intervals	[object]	false	none
»» end	string(date-time)	false	none
»» start	string(date-time)	false	none
» online_seconds	integer(int32)	true	none
» total_seconds	integer(int32)	true	none
» uptime	string	true	The uptime percentage of the agent

getAgentRTDStats

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/rtd \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/rtd',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/rtd',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/rtd', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/rtd',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/rtd", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/rtd

Returns the Round Trip Delay statistics for all devices monitored by the agent. The aggregate values of avg_min, avg_max, avg_median help to understand the baseline response time of a device in a weekly time frame, while latest_median helps detecting a possible deviation from the baseline

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/rtd \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "avg_max": "string",
    "avg_median": "string",
    "avg_min": "string",
    "device_id": 0,
    "latest_lost_packet_count": 0,
    "latest_median": "string",
    "latest_sent_packet_count": 0,
    "timestamp": "2019-08-24T14:15:22Z"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Devices RTD Statistics	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceRTDStatistics]	false	none
» avg_max	string	false	none
» avg_median	string	false	none
» avg_min	string	false	none
» device_id	integer(int32)	true	none
» latest_lost_packet_count	integer(int32)	false	The number of lost packets of the latest collection sample
» latest_median	string	false	The median value of the latest collection sample
» latest_sent_packet_count	integer(int32)	false	The number of sent packets of the latest collection sample
» timestamp	string(date-time)	true	The timestamp of the latest update

getDeviceStatusHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/history/network/event

Returns the time series of the state changes of the device

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/network/event \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "details": {
      "new_ip": [
        "string"
      ],
      "old_ip": [
        "string"
      ]
    },
    "timestamp": "2019-08-24T14:15:22Z",
    "type": "IP_CHANGE"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	A time series	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceHistory]	false	none
» details	object	false	none
»» new_ip	[string]	false	The new IP addresses
»» old_ip	[string]	false	The old IP addresses
» timestamp	string(date-time)	true	The time the sample was reported to Domotz
» type	string	true	The device event type

Enumerated Values

Property	Value
type	IP_CHANGE
type	CREATED
type	UP
type	DOWN

getDeviceRTDHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/history/rtd

Returns the Round Trip Delay history for the device. Each item represents the statistical aggregate of a set of Round Trip Delay measurements

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/history/rtd \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "lost_packet_count": 0,
    "max": "string",
    "median": "string",
    "min": "string",
    "sent_packet_count": 0,
    "timestamp": "2019-08-24T14:15:22Z"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Device RTD History	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceRTDHistorySample]	false	none
» lost_packet_count	integer(int32)	false	none
» max	string	false	none
» median	string	false	none
» min	string	false	none
» sent_packet_count	integer(int32)	false	none
» timestamp	string(date-time)	true	The time the sample was reported to Domotz

getDeviceUptime

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/uptime

Returns the uptime of the device

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/uptime \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

{
  "agent_uptime": "string",
  "downtime_intervals": [
    {
      "end": "2019-08-24T14:15:22Z",
      "start": "2019-08-24T14:15:22Z"
    }
  ],
  "online_seconds": 0,
  "total_seconds": 0,
  "uptime": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	The uptime of the device	DeviceUptime

getAgentStatusHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/history/network/event \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/history/network/event',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/history/network/event',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/history/network/event', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/history/network/event',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/history/network/event", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/history/network/event

Returns the time series of the state changes of the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/history/network/event \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "timestamp": "2019-08-24T14:15:22Z",
    "type": "CONNECTION_RECOVERED"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	A time series	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentHistory]	false	none
» timestamp	string(date-time)	true	The time the sample was reported to Domotz
» type	string	true	The agent event type

Enumerated Values

Property	Value
type	CONNECTION_RECOVERED
type	CONNECTION_LOST
type	UP
type	DOWN

getSpeedTestHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/history/network/speed \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/history/network/speed',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/history/network/speed',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/history/network/speed', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/history/network/speed',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/history/network/speed", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/history/network/speed

Returns the time series of the Internet Speed measurements taken from the agent, both in download and in upload.

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/history/network/speed \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "timestamp": "2019-08-24T14:15:22Z",
    "values": [
      0
    ]
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	A time series	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[NetworkSpeedSample]	false	[A Network Speed Sample is the result of the measurement of the Internet download and upload speed, in bits per second, taken by the Agent]
» timestamp	string(date-time)	false	The time the sample was reported to Domotz
» values	[integer]	false	A pair of values: the download and upload speed, in Bit Per Seconds (bps), as measured by the Agent

getAgentUptime

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/uptime \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/uptime',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/uptime',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/uptime', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/uptime',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/uptime", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/uptime

Returns the uptime of the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/uptime \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

{
  "agent_id": 0,
  "downtime_intervals": [
    {
      "end": "2019-08-24T14:15:22Z",
      "start": "2019-08-24T14:15:22Z"
    }
  ],
  "online_seconds": 0,
  "total_seconds": 0,
  "uptime": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	The uptime of the agent	AgentUptime

Activity Log

getAgentActivityLog

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/activity-log \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/activity-log',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/activity-log',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/activity-log', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/activity-log',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/activity-log", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/activity-log

Retrieves the activity log of an agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/activity-log \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now
type	query	string	false	If present, only the specified type(s) will be fetched.

Enumerated Values

Parameter	Value
type	note
type	agent_alert_level_set
type	agent_alert_resume
type	rtd_session_start
type	cresnet_node_reboot
type	device_reboot
type	firmware_update_start
type	applications_terminate
type	configuration_restore
type	factory_reset
type	network_configuration_change
type	custom_driver_execute
type	remote_session_start
type	remote_session_terminate
type	remote_session_limit_reached
type	vpn_session_start
type	vpn_session_terminate
type	chat_started
type	chat_resolved
type	operator_joined
type	operator_left
type	power_on
type	power_off
type	power_cycle
type	camera_snapshot
type	camera_streaming_start
type	configuration_management_status_change

[
  {
    "description": "string",
    "details": {},
    "device_id": 0,
    "timestamp": "2019-08-24T14:15:22Z",
    "type": "note",
    "user": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	List of activity log entries	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[ActivityLog]	false	[An activity log item]
» description	string	true	Description of the event
» details	object	false	Additional details of the event
» device_id	integer(int32)	false	Device that triggered the event (if applicable)
» timestamp	string(date-time)	true	Timestamp of the event
» type	string	true	Type of the event
» user	string	true	User who triggered the event

Enumerated Values

Property	Value
type	note
type	agent_alert_level_set
type	agent_alert_resume
type	rtd_session_start
type	cresnet_node_reboot
type	device_reboot
type	firmware_update_start
type	applications_terminate
type	configuration_restore
type	factory_reset
type	network_configuration_change
type	custom_driver_execute
type	remote_session_start
type	remote_session_terminate
type	remote_session_limit_reached
type	vpn_session_start
type	vpn_session_terminate
type	chat_started
type	chat_resolved
type	operator_joined
type	operator_left
type	power_on
type	power_off
type	power_cycle
type	camera_snapshot
type	camera_streaming_start
type	configuration_management_status_change

actions

createAgentVPNConnection

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session \
  -H 'Content-Type: application/json' \
  -H 'Accept: text/plain' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'Accept':'text/plain',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "allowed_ip": "string",
  "routing_policy": "global",
  "ttl_hours": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'text/plain',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'text/plain',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'text/plain',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"text/plain"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/connection/vpn-session

Creates a temporary VPN server on the agent and returns the vpn configuration file content. Current consumption and consumption limits can be retrieved with a call to getConnectionConsumption endpoint

{
  "allowed_ip": "string",
  "routing_policy": "global",
  "ttl_hours": 1
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session \ -H 'Content-Type: application/json' \ -H 'Accept: text/plain' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	AgentVPNConnection	true	none

Responses

Status	Meaning	Description	Schema
201	Created	OpenVPN Configuration file content	string

deleteAgentVPNConnection

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/connection/vpn-session/{vpn_session_id}

Closes an active VPN connection session for the agent

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/connection/vpn-session/{vpn_session_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
vpn_session_id	path	integer(int32)	true	Session ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

connectToDevice

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "allowed_ip": "string",
  "port": 0,
  "protocol": "http",
  "ttl_hours": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/connection

Establishes a direct secure connection to the device Current consumption and consumption limits can be retrieved with a call to getConnectionConsumption endpoint

{
  "allowed_ip": "string",
  "port": 0,
  "protocol": "http",
  "ttl_hours": 1
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/connection \ -H 'Content-Type: application/json' \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	DeviceConnection	true	none

{
  "allowed_ip": "string",
  "expiration": "2019-08-24T14:15:22Z",
  "id": 0,
  "link": "string",
  "port": 0,
  "protocol": "http"
}

Responses

Status	Meaning	Description	Schema
201	Created	none	ConnectionSession

device

deleteDownDevices

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device

Deletes all the DOWN devices of IP protocol

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

listDevices

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device

Returns all the devices of an agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
show_hidden	query	boolean	false	Whether to include hidden devices in the returned list

[
  {
    "authentication_status": "NO_AUTHENTICATION",
    "details": {
      "firmware_version": "string",
      "notes": "string",
      "room": "string",
      "serial": "string",
      "snmp_read_community": "string",
      "snmp_write_community": "string",
      "zone": "string"
    },
    "display_name": "string",
    "first_seen_on": "2019-08-24T14:15:22Z",
    "id": 0,
    "importance": "VITAL",
    "main_id": 0,
    "os": {
      "build": "string",
      "name": "string",
      "version": "string"
    },
    "protocol": "IP",
    "snmp_status": "CHECKING",
    "type": {
      "detected_id": 0,
      "id": 0,
      "label": "string"
    },
    "user_data": {
      "model": "string",
      "name": "string",
      "type": 0,
      "vendor": "string"
    }
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of all devices in the Agent's monitored networks	Inline

Response Schema

Enumerated Values

Property	Value
authentication_status	NO_AUTHENTICATION
authentication_status	AUTHENTICATED
authentication_status	PENDING
authentication_status	REQUIRED
authentication_status	WRONG_CREDENTIALS
importance	VITAL
importance	FLOATING
protocol	IP
protocol	DUMMY
protocol	IP_EXTERNAL
snmp_status	CHECKING
snmp_status	NOT_FOUND
snmp_status	NOT_AUTHENTICATED
snmp_status	AUTHENTICATED
status	ONLINE
status	OFFLINE
status	DOWN
status	HIDDEN

listAgentDeviceApplications

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/application \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/application',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/application',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/application', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/application',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/application", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/application

Retrieves the list of applications of all the devices belonging to the agent. The feature is only available on agents under the Enterprise Plan

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/application \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 1000. Default value is 100
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
name	query	string	false	Allows filtering by `name`
device_ids	query	string	false	Allows filtering by `device_ids`

[
  {
    "application_id": "string",
    "device_id": "string",
    "first_time_seen": "2019-08-24T14:15:22Z",
    "info": "string",
    "install_date": "2019-08-24T14:15:22Z",
    "install_location": "string",
    "last_modified": "2019-08-24T14:15:22Z",
    "last_update": "2019-08-24T14:15:22Z",
    "name": "string",
    "publisher": "string",
    "version": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of applications of all the devices belonging to the agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentDeviceApplication]	false	[The list of applications of all devices belonging to the agent]
» application_id	string	true	none
» device_id	string	true	none
» first_time_seen	string(date-time)	true	none
» info	string	false	none
» install_date	string(date-time)	false	none
» install_location	string	false	none
» last_modified	string(date-time)	false	none
» last_update	string(date-time)	false	none
» name	string	false	none
» publisher	string	false	none
» version	string	false	none

countAgentDeviceApplications

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/application \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/application',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/application',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent/{agent_id}/device/application', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent/{agent_id}/device/application',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent/{agent_id}/device/application", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent/{agent_id}/device/application

Counts the applications of all devices belonging to the agent. The feature is only available on agents under the Enterprise Plan

Curl

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/application \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
name	query	string	false	Allows filtering by `name`
device_ids	query	string	false	Allows filtering by `device_ids`

Responses

Status	Meaning	Description	Schema
204	No Content	Returns the application count	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	Returns the application count

createExternalHost

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/external-host \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/external-host',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "host": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/external-host',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/external-host', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/external-host',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/external-host", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/external-host

Creates an external host

{
  "host": "string",
  "name": "string"
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/external-host \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	ExternalHost	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

deleteDevice

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}

Deletes a device, whether ONLINE, OFFLINE or DOWN . If a device is deleted while online, it may reappear when rediscovered automatically

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getDevice

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id} \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}

Returns the details of a device

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id} \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	An object containing the device details	Inline

Response Schema

Enumerated Values

Property	Value
authentication_status	NO_AUTHENTICATION
authentication_status	AUTHENTICATED
authentication_status	PENDING
authentication_status	REQUIRED
authentication_status	WRONG_CREDENTIALS
importance	VITAL
importance	FLOATING
protocol	IP
protocol	DUMMY
protocol	IP_EXTERNAL
snmp_status	CHECKING
snmp_status	NOT_FOUND
snmp_status	NOT_AUTHENTICATED
snmp_status	AUTHENTICATED
status	ONLINE
status	OFFLINE
status	DOWN
status	HIDDEN

getDevicePowerActions

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/action/power

Returns the power management actions available on the device at the current moment.See DevicePowerAction schema for further details.

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

{
  "cycle": true,
  "off": true,
  "on": true,
  "software_reboot": true
}

Responses

Status	Meaning	Description	Schema
200	OK	Returns a JSON object indicating the current availability of each power action on the device	DevicePowerAction

powerActionOnDevice

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/action/power/{field}

Performs the action on the device, according to the specified { field } value. The availability of such operations can be determined with a call to getDevicePowerActions operation

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/action/power/{field} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
field	path	string	true	Specifies the power action to perform

Enumerated Values

Parameter	Value
field	on
field	off
field	cycle
field	software-reboot

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

listDeviceApplications

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/application

Retrieves the list of applications of the device. The feature is only available on agents under the Enterprise Plan

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 1000. Default value is 100
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
name	query	string	false	Allows filtering by `name`
device_ids	query	string	false	Allows filtering by `device_ids`

[
  {
    "application_id": "string",
    "first_time_seen": "2019-08-24T14:15:22Z",
    "info": "string",
    "install_date": "2019-08-24T14:15:22Z",
    "install_location": "string",
    "last_modified": "2019-08-24T14:15:22Z",
    "last_update": "2019-08-24T14:15:22Z",
    "name": "string",
    "publisher": "string",
    "version": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of applications of the device	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceApplication]	false	[The list of applications of a device]
» application_id	string	true	none
» first_time_seen	string(date-time)	true	none
» info	string	false	none
» install_date	string(date-time)	false	none
» install_location	string	false	none
» last_modified	string(date-time)	false	none
» last_update	string(date-time)	false	none
» name	string	false	none
» publisher	string	false	none
» version	string	false	none

countDeviceApplications

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent/{agent_id}/device/{device_id}/application

Counts the applications. The feature is only available on agents under the Enterprise Plan

Curl

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/application \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
name	query	string	false	Allows filtering by `name`
device_ids	query	string	false	Allows filtering by `device_ids`

Responses

Status	Meaning	Description	Schema
204	No Content	Returns the application count	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	Returns the application count

setCredentials

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "password": "string",
  "scope": "DEVICE_MANAGEMENT",
  "username": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/credentials

Sets the device credentials to perform extended discovery. This operation will affect the authentication_status of the device

{
  "password": "string",
  "scope": "DEVICE_MANAGEMENT",
  "username": "string"
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/credentials \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	DeviceCredentials	true	device credentials payload

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getDeviceOutlets

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/power-outlet

Returns a list of the power outlets discovered on the device

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

[
  {
    "can_write": true,
    "custom_name": "string",
    "device_id": 0,
    "id": "string",
    "links": [
      0
    ],
    "name": "string",
    "power": "ON"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	A list of outlet objects	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceOutlet]	false	[Power outlet of a device]
» can_write	boolean	true	True if power actions can be executed on the outlet
» custom_name	string	false	Name of the outlet assigned by the user
» device_id	integer(int32)	true	Unique identifier of the device the outlet belongs to
» id	string	true	Unique identifier of the outlet
» links	[integer]	true	List of device ids attached to the outlet
» name	string	true	Name of the outlet discovered automatically
» power	string	true	The current power state of the outlet

Enumerated Values

Property	Value
power	ON
power	OFF
power	unknown

updateDeviceOutlet

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "custom_name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}

Update the power outlet with the specified custom name

{
  "custom_name": "string"
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
power_outlet_id	path	string	true	Outlet ID
body	body	DeviceOutletUpdate	false	none

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

triggerOutletAction

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action}

Trigger an action on a power outlet

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/action/{action} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
power_outlet_id	path	string	true	Outlet ID
action	path	string	true	Action to perform on the outlet

Enumerated Values

Parameter	Value
action	on
action	off
action	cycle

Responses

Status	Meaning	Description	Schema
202	Accepted	none	None

detachDeviceFromOutlet

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}

Detach a device from a power outlet

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
power_outlet_id	path	string	true	Outlet ID
attached_device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

attachDeviceToOutlet

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id}

Attach a device to a power outlet

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/power-outlet/{power_outlet_id}/attach/{attached_device_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
power_outlet_id	path	string	true	Outlet ID
attached_device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getSNMPAuthentication

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/snmp-authentication

Retrieves the SNMP authentication info

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

{
  "authentication_key": "string",
  "authentication_protocol": "MD5",
  "encryption_key": "string",
  "encryption_protocol": "DES",
  "snmp_read_community": "string",
  "snmp_write_community": "string",
  "username": "string",
  "version": "V2"
}

Responses

Status	Meaning	Description	Schema
200	OK	The SNMP authentication info for the device	SNMPDomotzAuthentication

setSNMPAuthentication

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authentication_key": "string",
  "authentication_protocol": "MD5",
  "encryption_key": "string",
  "encryption_protocol": "DES",
  "snmp_read_community": "string",
  "snmp_write_community": "string",
  "username": "string",
  "version": "V2"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/snmp-authentication

Sets the SNMP authentication info.

snmp_read_community and snmp_write_community are relevant only for V1 and V2.
V3_NO_AUTH requires a valid username.
V3_AUTH_NO_PRIV requires username, authentication_protocol and authentication_key.
V3_AUTH_PRIV requires username, authentication_protocol, authentication_key, encryption_protocol and encryption_key.

{
  "authentication_key": "string",
  "authentication_protocol": "MD5",
  "encryption_key": "string",
  "encryption_protocol": "DES",
  "snmp_read_community": "string",
  "snmp_write_community": "string",
  "username": "string",
  "version": "V2"
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-authentication \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	SNMPDomotzAuthentication	true	none

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

setSnmpCommunity

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "read": "string",
  "write": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/snmp-community

Saves a snmp community (read, optionally write) on device. Deprecated, please use setSNMPAuthentication

{
  "read": "string",
  "write": "string"
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/snmp-community \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	DeviceSnmpCommunity	true	The value that the snmp community entries will change to

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

hideDevice

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/visibility

Hides a device (available only on DOWN devices)

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/visibility \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

editDevice

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = 'string';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/{field}

Changes a field of the device or one of its details

"string"

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/{field} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
field	path	string	true	The field to update - for the type and valid values see the description of the corresponding output parameter here
body	body	string	true	The value that the field will change to

Enumerated Values

Parameter	Value
field	importance
field	user_data/model
field	user_data/type
field	user_data/name
field	user_data/vendor
field	details/room
field	details/zone
field	details/serial
field	details/notes

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

SNMP/TCP SENSORS

listAgentEyesSNMP

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/eye/snmp

Retrieves the list of configured SNMP Domotz Sensors on the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/eye/snmp \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "category": "OTHER",
    "device_id": 0,
    "id": 0,
    "name": "string",
    "oid": "string",
    "value_type": "STRING"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured SNMP Domotz Sensors on the agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[SNMPDomotzAgentEye]	false	[Information about a configured SNMP Domotz Sensor]
» category	string	true	The category of the OID
» device_id	integer(int32)	false	The unique identifier of the device
» id	integer(int32)	true	The ID of the SNMP Domotz Sensor
» name	string	true	The name of the Domotz Sensors
» oid	string	true	The OID string
» value_type	string	true	The type of the OID

Enumerated Values

Property	Value
category	OTHER
category	CONSUMABLE
category	CPU
category	DISK_SPACE
category	MEMORY
category	NETWORK_TRAFFIC
category	TEMPERATURE
value_type	STRING
value_type	NUMERIC
value_type	ENUM

listAgentEyesTCP

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/eye/tcp

Retrieves the list of configured TCP Domotz Sensors on the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/eye/tcp \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "device_id": 0,
    "id": 0,
    "last_update": "2019-08-24T14:15:22Z",
    "port": 0,
    "status": "UP"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured TCP Domotz Sensors on the agent and their latest values	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[TCPDomotzEye]	false	[Information about a configured TCP Domotz Sensor]
» device_id	integer(int32)	false	The unique identifier of the device
» id	integer(int32)	true	The ID of the TCP Domotz Sensor
» last_update	string(date-time)	true	The timestamp of the latest update
» port	integer(int32)	true	The port number
» status	string	true	The status of the TCP service

Enumerated Values

Property	Value
status	UP
status	DOWN

listEyesSNMP

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/eye/snmp

Retrieves the list of configured SNMP Domotz Sensors

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

[
  {
    "category": "OTHER",
    "device_id": 0,
    "id": 0,
    "last_update": "2019-08-24T14:15:22Z",
    "latest_enum_value": "string",
    "latest_value": "string",
    "name": "string",
    "oid": "string",
    "value_type": "STRING"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured SNMP Domotz Sensors for the device and their latest values	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[SNMPDomotzEye]	false	[Information about a configured SNMP Domotz Sensor]
» category	string	true	The category of the OID
» device_id	integer(int32)	false	The unique identifier of the device
» id	integer(int32)	true	The ID of the SNMP Domotz Sensor
» last_update	string(date-time)	true	The timestamp of the latest update
» latest_enum_value	string	false	The enum value retrieved on the OID
» latest_value	string	true	The value retrieved on the OID
» name	string	true	The name of the Domotz Sensors
» oid	string	true	The OID string
» value_type	string	true	The type of the OID

Enumerated Values

Property	Value
category	OTHER
category	CONSUMABLE
category	CPU
category	DISK_SPACE
category	MEMORY
category	NETWORK_TRAFFIC
category	TEMPERATURE
value_type	STRING
value_type	NUMERIC
value_type	ENUM

createEyeSNMP

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "category": "OTHER",
  "name": "string",
  "oid": "string",
  "value_type": "STRING"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/eye/snmp

Creates a new SNMP Domotz Sensors

{
  "category": "OTHER",
  "name": "string",
  "oid": "string",
  "value_type": "STRING"
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	SNMPDomotzEyeCreation	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

deleteEyeSNMP

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}

Deletes the SNMP Domotz Sensor

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

listEyesSNMPTriggerFunction

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function

Retrieves the list of functions for the SNMP trigger Domotz Sensors

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/function \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID

[
  {
    "cardinality": 0,
    "id": 0,
    "name": "string",
    "value_types": "STRING"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of functions that can be used by the trigger	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[SNMPDomotzEyeTriggerFunction]	false	[Information about a trigger function]
» cardinality	integer(int32)	true	The number of arguments of the function
» id	integer(int32)	true	The unique identifier of the SNMP Trigger function
» name	string	true	The name of the function
» value_types	string	true	The type of the operands

Enumerated Values

Property	Value
value_types	STRING
value_types	NUMERIC
value_types	ENUM

getEyesSNMPHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history

Returns the time series of the SNMP Domotz Sensors collected samples

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/history \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "enum_value": "string",
    "timestamp": "2019-08-24T14:15:22Z",
    "value": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of SNMP Domotz Sensors samples	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceEyeSNMPHistorySample]	false	none
» enum_value	string	false	none
» timestamp	string(date-time)	true	The time the sample was reported to Domotz
» value	string	true	none

listEyesSNMPTrigger

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger

Retrieves the list of triggers for the SNMP Sensor

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID

[
  {
    "alert": {
      "email": true,
      "mobile": true
    },
    "creation_time": "2019-08-24T14:15:22Z",
    "function_id": 0,
    "id": 0,
    "name": "string",
    "operands": [
      "string"
    ]
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of triggers associated to the sensor	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[SNMPDomotzEyeTrigger]	false	[Information about a trigger]
» alert	object	false	The alerts details
»» email	boolean	false	True if the email alert is active
»» mobile	boolean	false	True if the mobile alert is active
» creation_time	string(date-time)	false	none
» function_id	integer(int32)	true	The unique identifier of the function assigned to the trigger
» id	integer(int32)	true	The unique identifier of the SNMP Trigger
» name	string	true	The name of the trigger
» operands	[string]	true	The operands for the function

createEyeSNMPTrigger

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "function_id": 0,
  "name": "string",
  "operands": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger

Creates a new SNMP Trigger for the sensor.

For instance, to receive a notification when the value of the sensor is above a threshold x, it is required to add a trigger specifying the function_id = 2 (is greater than) and the operand value equals to [x]. The function_id value can be retrieved with the listEyesSNMPTriggerFunction call. To activate the alert, it is required to call createEyeSNMPTriggerAlert after the trigger creation.

{
  "function_id": 0,
  "name": "string",
  "operands": [
    "string"
  ]
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID
body	body	SNMPDomotzSnmpTriggerCreation	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

deleteEyeSNMPTrigger

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}

Deletes the SNMP Trigger for the sensor

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID
trigger_id	path	integer(int32)	true	SNMP Sensor Trigger ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

deleteEyeSNMPTriggerAlert

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}

Deletes the alert for thee SNMP Trigger

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID
trigger_id	path	integer(int32)	true	SNMP Sensor Trigger ID
medium_name	path	string	true	the name of the medium

Enumerated Values

Parameter	Value
medium_name	email
medium_name	mobile

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

createEyeSNMPTriggerAlert

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name}

Add an alert to a SNMP Trigger

{}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/snmp/{sensor_id}/trigger/{trigger_id}/alert/{medium_name} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
sensor_id	path	integer(int32)	true	SNMP Sensor ID
trigger_id	path	integer(int32)	true	SNMP Sensor Trigger ID
medium_name	path	string	true	the name of the medium
body	body	SNMPDomotzSnmpTriggerAlertCreation	true	none

Enumerated Values

Parameter	Value
medium_name	email
medium_name	mobile

Responses

Status	Meaning	Description	Schema
201	Created	none	None

listEyesTCP

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/eye/tcp

Retrieves the list of configured TCP Domotz Sensors

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

[
  {
    "device_id": 0,
    "id": 0,
    "last_update": "2019-08-24T14:15:22Z",
    "port": 0,
    "status": "UP"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured TCP Domotz Sensors for the device and their latest values	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[TCPDomotzEye]	false	[Information about a configured TCP Domotz Sensor]
» device_id	integer(int32)	false	The unique identifier of the device
» id	integer(int32)	true	The ID of the TCP Domotz Sensor
» last_update	string(date-time)	true	The timestamp of the latest update
» port	integer(int32)	true	The port number
» status	string	true	The status of the TCP service

Enumerated Values

Property	Value
status	UP
status	DOWN

createEyeTCP

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "port": 0
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/device/{device_id}/eye/tcp

Creates a new TCP Domotz Sensors

{
  "port": 0
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	TCPDomotzEyeCreation	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

deleteEyeTCP

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/eye/tcp/{service_id}

Deletes the TCP Domotz Sensor

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/eye/tcp/{service_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
service_id	path	integer(int32)	true	TCP Sensor ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

eyesUsageInfo

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/eye-statistics \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/eye-statistics',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/eye-statistics',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/eye-statistics', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/eye-statistics',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/eye-statistics", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/eye-statistics

Retrieves information about Domotz Sensors usage and limits

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/eye-statistics \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "limit": 0,
  "usage": {
    "snmp": 0,
    "tcp": 0,
    "total": 0
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A data structure containing information about current Domotz Sensors usage and limits	DomotzEyesUsageInformation

MetricUsageInfo

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/metric-statistics \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/metric-statistics',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/metric-statistics',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/metric-statistics', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/metric-statistics',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/metric-statistics", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/metric-statistics

Returns Domotz Sensors usage and limits

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/metric-statistics \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "limit": 0,
  "usage": {
    "custom_driver": 0,
    "snmp": 0,
    "tcp": 0,
    "total": 0
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Current Domotz Sensors usage and limits	DomotzMetricUsageInformation

variables

listAgentDeviceVariables

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/variable \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/variable

Retrieves the list of all device variables of the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/variable \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 1000. Default value is 100
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
sort_by	query	string	false	Allows ordering by `path`, `id`, `value`, `label`, `value_update_time`, `creation_time`, `device_id`
sorting_direction	query	string	false	The default is `asc`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Enumerated Values

Parameter	Value
sort_by	path
sort_by	id
sort_by	value
sort_by	label
sort_by	value_update_time
sort_by	creation_time
sort_by	device_id
sorting_direction	asc
sorting_direction	desc

[
  {
    "creation_time": "2019-08-24T14:15:22Z",
    "device_id": 0,
    "has_history": true,
    "id": 0,
    "label": "string",
    "metric": "string",
    "path": "string",
    "previous_value": "string",
    "unit": "string",
    "value": "string",
    "value_update_time": "2019-08-24T14:15:22Z"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of all device variables of an agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentDeviceVariable]	false	[The representation of a device variable]
» creation_time	string(date-time)	false	The creation time of the variable
» device_id	integer(int32)	true	The ID of the device
» has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
» id	integer(int32)	true	The ID of the variable
» label	string	false	The label
» metric	string	false	The metric
» path	string	true	The variable path
» previous_value	string	false	The previous value of the variable
» unit	string	false	The unit of measurement
» value	string	false	The variable value
» value_update_time	string(date-time)	false	The update time of the variable value

countAgentDeviceVariables

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/variable \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent/{agent_id}/device/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent/{agent_id}/device/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent/{agent_id}/device/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent/{agent_id}/device/variable

Returns the device variables count of the agent

Curl

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/variable \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Responses

Status	Meaning	Description	Schema
204	No Content	The device variables count	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	The device variables count

listDeviceVariables

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/variable

Retrieves the list of device variables

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 1000. Default value is 100
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
sort_by	query	string	false	Allows ordering by `path`, `id`, `value`, `label`, `value_update_time`, `creation_time`
sorting_direction	query	string	false	The default is `asc`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Enumerated Values

Parameter	Value
sort_by	path
sort_by	id
sort_by	value
sort_by	label
sort_by	value_update_time
sort_by	creation_time
sorting_direction	asc
sorting_direction	desc

[
  {
    "creation_time": "2019-08-24T14:15:22Z",
    "has_history": true,
    "id": 0,
    "label": "string",
    "metric": "string",
    "path": "string",
    "previous_value": "string",
    "unit": "string",
    "value": "string",
    "value_update_time": "2019-08-24T14:15:22Z"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of device variables	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceVariable]	false	[The representation of a device variable]
» creation_time	string(date-time)	false	The creation time of the variable
» has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
» id	integer(int32)	true	The ID of the variable
» label	string	false	The label
» metric	string	false	The metric
» path	string	true	The variable path
» previous_value	string	false	The previous value of the variable
» unit	string	false	The unit of measurement
» value	string	false	The variable value
» value_update_time	string(date-time)	false	The update time of the variable value

countDeviceVariables

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent/{agent_id}/device/{device_id}/variable

Returns device variables count

Curl

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Responses

Status	Meaning	Description	Schema
204	No Content	The device variables count	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	The device variables count

getVariableHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/variable/{variable_id}/history

Returns the variable history

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/variable/{variable_id}/history \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
variable_id	path	integer(int32)	true	Variable ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "timestamp": "2019-08-24T14:15:22Z",
    "value": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The variable's history, a list of dictionaries, each composed by the timestamp (a datetime) and the value (a string)	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[VariableHistorySample]	false	none
» timestamp	string(date-time)	true	The time the sample was reported to Domotz
» value	string	true	The sample value

listAgentVariables

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/variable \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/variable',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/variable',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/variable

Retrieves the list of all agent variables of the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/variable \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
page_size	query	integer(int32)	false	The maximum number of items to return. Min value is 1. Max value is 1000. Default value is 100
page_number	query	integer(int32)	false	The requested page number, 0-indexed. Default value is 0
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
sort_by	query	string	false	Allows ordering by `path`, `id`, `value`, `label`, `value_update_time`, `creation_time`
sorting_direction	query	string	false	The default is `asc`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Enumerated Values

Parameter	Value
sort_by	path
sort_by	id
sort_by	value
sort_by	label
sort_by	value_update_time
sort_by	creation_time
sorting_direction	asc
sorting_direction	desc

[
  {
    "creation_time": "2019-08-24T14:15:22Z",
    "has_history": true,
    "id": 0,
    "label": "string",
    "metric": "string",
    "path": "string",
    "previous_value": "string",
    "unit": "string",
    "value": "string",
    "value_update_time": "2019-08-24T14:15:22Z"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of all agent variables of the agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentVariable]	false	[The representation of an agent variable]
» creation_time	string(date-time)	false	The creation time of the variable
» has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
» id	integer(int32)	true	The ID of the variable
» label	string	false	The label
» metric	string	false	The metric
» path	string	true	The variable path
» previous_value	string	false	The previous value of the variable
» unit	string	false	The unit of measurement
» value	string	false	The variable value
» value_update_time	string(date-time)	false	The update time of the variable value

countAgentVariables

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/variable \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/variable',
  method: 'head',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/variable',
{
  method: 'HEAD',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.head('{baseURL}/public-api/v1/agent/{agent_id}/variable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.head '{baseURL}/public-api/v1/agent/{agent_id}/variable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "{baseURL}/public-api/v1/agent/{agent_id}/variable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

HEAD /agent/{agent_id}/variable

Returns the agent variables count of the agent

Curl

curl -X HEAD {baseURL}/public-api/v1/agent/{agent_id}/variable \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
value	query	string	false	Allows filtering by `value`
path	query	string	false	Allows filtering by `path`
has_history	query	boolean	false	Allows filtering by `has_history` field
metric	query	string	false	Allows filtering by `metric`

Responses

Status	Meaning	Description	Schema
204	No Content	The agent variables count	None

Response Headers

Status	Header	Type	Format	Description
204	X-Entities-Count	integer	int32	The agent variables count

getAgentVariableHistory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/variable/{variable_id}/history

Returns the agent variable history

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/variable/{variable_id}/history \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
variable_id	path	integer(int32)	true	Variable ID
from	query	string(date-time)	false	The start time of the time series. Default value is one week
to	query	string(date-time)	false	The end time of the time series. Default value is now

[
  {
    "timestamp": "2019-08-24T14:15:22Z",
    "value": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The agent variable's history, a list of dictionaries, each composed by the timestamp (a datetime) and the value (a string)	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[VariableHistorySample]	false	none
» timestamp	string(date-time)	true	The time the sample was reported to Domotz
» value	string	true	The sample value

inventory

getDeviceInventory

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/inventory

Returns the device's inventory data

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

[
  {
    "creation_time": "2019-08-24T14:15:22Z",
    "key": "string",
    "value": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The device's inventory, with the fields sorted alphabetically. Not set fields will be null	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceInventoryField]	false	[A device inventory field]
» creation_time	string(date-time)	false	none
» key	string	true	The name of the field, unique in the Inventory
» value	string	true	none

deleteDeviceInventoryField

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/device/{device_id}/inventory/{inventory_field}

Deletes the Inventory field for the device

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
inventory_field	path	string	true	Field identifier, unique within the Inventory

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

setDeviceInventoryFieldValue

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = 'string';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/device/{device_id}/inventory/{inventory_field}

Sets the value of an Inventory field for the device, a value can't be set to null

"string"

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/inventory/{inventory_field} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
inventory_field	path	string	true	Field identifier, unique within the Inventory
body	body	string	true	none

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

deleteInventory

curl -X DELETE {baseURL}/public-api/v1/inventory \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/inventory',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/inventory',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/inventory', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/inventory',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/inventory", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /inventory

Clears the inventory

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getInventory

curl -X GET {baseURL}/public-api/v1/inventory \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/inventory',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/inventory',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/inventory', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/inventory',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/inventory", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /inventory

Enumerates all the Inventory fields

[
  {
    "label": "string",
    "creation_time": "2019-08-24T14:15:22Z",
    "defined_by_user": 0,
    "key": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The inventory fields, sorted by creation time	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[allOf]	false	none

allOf

Name	Type	Required	Description
» anonymous	WriteInventoryField	false	DTO Used for creating/updating Inventory fields
»» label	string	true	A detailed description of the field, for documentation

and

Name	Type	Required	Description
» anonymous	object	false	DTO Returned by the API describing an Inventory Field
»» creation_time	string(date-time)	false	none
»» defined_by_user	integer(int32)	false	The `id` of the user that defined the inventory field - if different from your id, this field can't be deleted or changed
»» key	string	true	The name of the field, unique in the Inventory

deleteInventoryField

curl -X DELETE {baseURL}/public-api/v1/inventory/{inventory_field} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/inventory/{inventory_field}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/inventory/{inventory_field}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/inventory/{inventory_field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/inventory/{inventory_field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/inventory/{inventory_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /inventory/{inventory_field}

Deletes the Inventory Field

Curl

curl -X DELETE {baseURL}/public-api/v1/inventory/{inventory_field} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
inventory_field	path	string	true	Field identifier, unique within the Inventory

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

createInventoryField

curl -X POST {baseURL}/public-api/v1/inventory/{inventory_field} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/inventory/{inventory_field}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "label": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/inventory/{inventory_field}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/inventory/{inventory_field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/inventory/{inventory_field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/inventory/{inventory_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /inventory/{inventory_field}

Creates a new Inventory Field - the user will be able to set key-values pairs on every device

{
  "label": "string"
}

Curl

curl -X POST {baseURL}/public-api/v1/inventory/{inventory_field} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
inventory_field	path	string	true	Field identifier, unique within the Inventory
body	body	WriteInventoryField	true	none

Responses

Status	Meaning	Description	Schema
201	Created	The inventory field will be referenced to with its name	None

updateInventoryField

curl -X PUT {baseURL}/public-api/v1/inventory/{inventory_field} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/inventory/{inventory_field}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "label": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/inventory/{inventory_field}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/inventory/{inventory_field}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/inventory/{inventory_field}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/inventory/{inventory_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /inventory/{inventory_field}

Updates the Inventory Field

{
  "label": "string"
}

Curl

curl -X PUT {baseURL}/public-api/v1/inventory/{inventory_field} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
inventory_field	path	string	true	Field identifier, unique within the Inventory
body	body	WriteInventoryField	true	none

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

multimedia

onvifSnapshot

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot \
  -H 'Accept: image/*' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'image/*',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'image/*',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'image/*',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'image/*',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"image/*"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot

Take a snapshot of the camera. Internally, a device connection is established.Current consumption and consumption limits can be retrieved with a call to getConnectionConsumption endpoint

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/device/{device_id}/multimedia/camera/snapshot \ -H 'Accept: image/*' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
200	OK	A binary image	string

networking

getAgentIPConflicts

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/ip-conflict \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/ip-conflict',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/ip-conflict',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/ip-conflict', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/ip-conflict',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/ip-conflict", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/ip-conflict

Returns the list of active IP conflicts on an agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/ip-conflict \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "conflicting_devices": [
      {
        "id": 0,
        "mac": "string"
      }
    ],
    "ip": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AgentIpConflict]	false	none
» conflicting_devices	[object]	false	none
»» id	integer(int32)	false	none
»» mac	string	false	none
» ip	string	false	none

setDHCPDeviceDiscovery

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "dhcp_device_discovery": true
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/network/dhcp-device-discovery

Enable/disable the Agent DHCP Device Discovery

{
  "dhcp_device_discovery": true
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/dhcp-device-discovery \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	DHCPDeviceDiscoverySetting	true	Enable/disable the DHCP Device Discovery on the agent

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

deleteAgentExternalHostScanPolicy

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/network/external-host-scan-policy

Restore the external host scan policy to default.

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getAgentExternalHostScanPolicy

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/network/external-host-scan-policy

Returns the current external host scan policy.

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "icmp": {
    "enabled": true
  },
  "tcp_ack": {
    "enabled": true,
    "ports": [
      0
    ]
  },
  "tcp_syn": {
    "enabled": true,
    "ports": [
      0
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	The external host scan policy.	AgentExternalHostScanPolicy

setAgentExternalHostScanPolicy

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "icmp": {
    "enabled": true
  },
  "tcp_ack": {
    "enabled": true,
    "ports": [
      0
    ]
  },
  "tcp_syn": {
    "enabled": true,
    "ports": [
      0
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/network/external-host-scan-policy

Updates the current external host scan policy. It is possible to enable/disable each one of the three available methods (ICMP, TCP-SYN, TCP-ACK). For TCP-SYN and TCP-ACK is mandatory to specify a set of TCP ports. If a method is not specified in the payload of the request, it will be configured as disabled

{
  "icmp": {
    "enabled": true
  },
  "tcp_ack": {
    "enabled": true,
    "ports": [
      0
    ]
  },
  "tcp_syn": {
    "enabled": true,
    "ports": [
      0
    ]
  }
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/external-host-scan-policy \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	AgentExternalHostScanPolicy	true	The external host scan policy to be applied

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getAgentInterfaces

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/network/interfaces

Returns the networks monitored by the agent

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "attached": [
    {
      "address": "string",
      "mac_address": "string",
      "name": "string",
      "netmask": 0
    }
  ],
  "routed": [
    {
      "address": "string",
      "name": "string",
      "netmask": 0
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	The networks monitored by the agent	AllAgentInterfaces

deleteAgentInterfacesPolicy

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/network/interfaces-policy

Resets the network interface filtering policy to the default value

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getAgentInterfacesPolicy

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/network/interfaces-policy

Returns the current network interface filtering policy. The interfaces policy defines the set of interfaces which will be ignored (deny) or scanned (allow) by the agent. The default behavior is to scan all available interfaces

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "policy": "allow",
  "rules": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	The current network interface filtering policy	AgentInterfacesPolicy

setAgentInterfacesPolicy

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "policy": "allow",
  "rules": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/network/interfaces-policy

Updates the current network interface filtering policy

{
  "policy": "allow",
  "rules": [
    "string"
  ]
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/interfaces-policy \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	AgentInterfacesPolicy	true	the filtering policy to be applied

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

deleteAgentIPScanPolicy

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /agent/{agent_id}/network/ip-scan-policy

Resets the IP scan policy to the default value

Curl

curl -X DELETE {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getAgentIPScanPolicy

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/network/ip-scan-policy

Returns the current IP addresses management policy. It is possible to specify a set of IP addresses in the forced_ip_addresses field array or a set of IP address ranges in the forced_ip_ranges field array to be always scanned.

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "forced_ip_addresses": [
    "string"
  ],
  "forced_ip_ranges": [
    {
      "end": "string",
      "start": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	The IP scan policy.	AgentIPScanPolicy

setAgentIPScanPolicy

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "forced_ip_addresses": [
    "string"
  ],
  "forced_ip_ranges": [
    {
      "end": "string",
      "start": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/network/ip-scan-policy

Updates the current IP address scan policy. The list of IP addresses provided in forced_ip_addresses and the list of IP address ranges provided in forced_ip_ranges will be scanned regardless of the automatic discovery settings of the agent.

{
  "forced_ip_addresses": [
    "string"
  ],
  "forced_ip_ranges": [
    {
      "end": "string",
      "start": "string"
    }
  ]
}

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/network/ip-scan-policy \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	AgentIPScanPolicy	true	the IP scan policy to be applied

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

createRoutedNetwork

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/network/routed \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network/routed',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "address": "string",
  "name": "string",
  "netmask": 0
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network/routed',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/agent/{agent_id}/network/routed', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/agent/{agent_id}/network/routed',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/agent/{agent_id}/network/routed", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /agent/{agent_id}/network/routed

Creates a routed network

{
  "address": "string",
  "name": "string",
  "netmask": 0
}

Curl

curl -X POST {baseURL}/public-api/v1/agent/{agent_id}/network/routed \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
body	body	RoutedNetwork	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

topology

getNetworkTopology

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network-topology \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/network-topology',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/network-topology',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/agent/{agent_id}/network-topology', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/agent/{agent_id}/network-topology',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/agent/{agent_id}/network-topology", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /agent/{agent_id}/network-topology

Returns the agent's network topology

Curl

curl -X GET {baseURL}/public-api/v1/agent/{agent_id}/network-topology \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

{
  "edges": [
    {
      "from": 0,
      "to": 0
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	none	NetworkTopology

company

moveAgent

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /agent/{agent_id}/ownership/team/{team_id}

Moves an agent under the control of a different team. Note: This API is restricted to users on the Enterprise Plan. Please contact sales@domotz.com to learn more.

Curl

curl -X PUT {baseURL}/public-api/v1/agent/{agent_id}/ownership/team/{team_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
team_id	path	integer(int32)	true	Team ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

listAreas

curl -X GET {baseURL}/public-api/v1/area \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/area',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/area',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/area', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/area',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/area", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /area

Returns all the areas of a Company. Note: This API is restricted to users on the Enterprise Plan. Please contact sales@domotz.com to learn more.

[
  {
    "id": 0,
    "name": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of all the areas in the User's Company	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[Area]	false	[Represents an area of the Company]
» id	integer(int32)	true	The identifier of the Area
» name	string	true	The name of the Area

listTeams

curl -X GET {baseURL}/public-api/v1/area/{area_id}/team \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/area/{area_id}/team',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/area/{area_id}/team',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/area/{area_id}/team', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/area/{area_id}/team',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/area/{area_id}/team", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /area/{area_id}/team

Returns all the teams of an Area. Note: This API is restricted to users on the Enterprise Plan. Please contact sales@domotz.com to learn more.

Curl

curl -X GET {baseURL}/public-api/v1/area/{area_id}/team \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
area_id	path	integer(int32)	true	Area ID

[
  {
    "id": 0,
    "name": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of all the teams in a Company Area's	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[Team]	false	[Represents a team of the Company]
» id	integer(int32)	true	The identifier of the Team
» name	string	true	The name of the Team

createTeam

curl -X POST {baseURL}/public-api/v1/area/{area_id}/team \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/area/{area_id}/team',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "leader": {
    "details": {
      "display_name": "string"
    },
    "name": "string",
    "password": "string"
  },
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/area/{area_id}/team',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/area/{area_id}/team', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/area/{area_id}/team',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/area/{area_id}/team", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /area/{area_id}/team

Creates a new Team. Note: This API is restricted to users on the Enterprise Plan. Please contact sales@domotz.com to learn more.

{
  "leader": {
    "details": {
      "display_name": "string"
    },
    "name": "string",
    "password": "string"
  },
  "name": "string"
}

Curl

curl -X POST {baseURL}/public-api/v1/area/{area_id}/team \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
area_id	path	integer(int32)	true	Area ID
body	body	TeamCreation	true	none

Responses

Status	Meaning	Description	Schema
201	Created	none	None

alert profiles

getAlertProfiles2

curl -X GET {baseURL}/public-api/v1/alert-profile \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/alert-profile', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/alert-profile',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/alert-profile", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /alert-profile

Returns the list of configured alert profiles. You can configure alert profiles on the Domotz Portal. Alert profiles define the association between a list of events and a notification channel (email, webhook or slack)

[
  {
    "description": "string",
    "events": [
      "device_status_up"
    ],
    "id": 0,
    "is_enabled": true,
    "name": "string",
    "tag": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured alert profiles	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AlertProfile]	false	none
» description	string	false	The description of the alert profile
» events	[string]	false	The list of events associated to the profile
» id	integer(int32)	true	The id of the event profile
» is_enabled	boolean	false	true if the event profile is enabled, false otherwise
» name	string	false	The symbolic name associated to the profile
» tag	string	false	A label associated to the profile

getAgentAlertProfile

curl -X GET {baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id} \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /alert-profile/binding/agent/{agent_id}

Get the alert profile bindings of an agent

Curl

curl -X GET {baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id} \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "alert_profile_id": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The alert profile bindings of an agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AlertProfileAgentBinding]	false	none
» alert_profile_id	integer(int32)	true	The id of the alert profile

getDevicesAlertProfile

curl -X GET {baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /alert-profile/binding/agent/{agent_id}/device

Get the alert profile bindings of the devices of an agent

Curl

curl -X GET {baseURL}/public-api/v1/alert-profile/binding/agent/{agent_id}/device \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "alert_profile_id": 0,
    "device_id": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The alert profile bindings for all devices of the agent	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AlertProfileDeviceBinding]	false	none
» alert_profile_id	integer(int32)	true	The id of the alert profile
» device_id	integer(int32)	true	none

unbindAlertProfileFromAgent

curl -X DELETE {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /alert-profile/{alert_profile_id}/binding/agent/{agent_id}

Unbind an alert profile from an agent.

Curl

curl -X DELETE {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
alert_profile_id	path	integer(int32)	true	Profile ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

bindAlertProfileToAgent

curl -X POST {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /alert-profile/{alert_profile_id}/binding/agent/{agent_id}

Bind an alert profile to an agent. After binding, a webhook will be sent to the configured service when one of the events associated to the profile occurs. You can configure the profile and the webhook endpoint on the Domotz Portal

Curl

curl -X POST {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
alert_profile_id	path	integer(int32)	true	Profile ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

Webhook Events

Event Name	Method	Schema	Expected Reply
agent_device_discovery	POST	DeviceDiscoveryEvent	201
agent_feature_discovery	POST	FeatureDiscoveryEvent	201
agent_feature_discovery_mib	POST	MibDiscoveryEvent	201
agent_lan_change	POST	AgentLANChangeEvent	201
agent_security_issue	POST	AgentSecurityIssueEvent	201
agent_speed_test	POST	AgentSpeedTestEvent	201
agent_status_down	POST	AgentStatusEvent	201
agent_status_up	POST	AgentStatusEvent	201
agent_wan_change	POST	AgentWANChangeEvent	201

unbindAlertProfileFromDevice

curl -X DELETE {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}

Unbind an alert profile from a device

Curl

curl -X DELETE {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
alert_profile_id	path	integer(int32)	true	Profile ID
device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

bindAlertProfileToDevice

curl -X POST {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id}

Bind an alert profile to a device. After binding, a webhook will be sent to the configured service when one of the events associated to the profile occurs. You can configure the profile and the webhook endpoint on the Domotz Portal

Curl

curl -X POST {baseURL}/public-api/v1/alert-profile/{alert_profile_id}/binding/agent/{agent_id}/device/{device_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID
alert_profile_id	path	integer(int32)	true	Profile ID
device_id	path	integer(int32)	true	Device ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

Webhook Events

Event Name	Method	Schema	Expected Reply
device_configuration_change	POST	DeviceConfigurationChangeEvent	201
device_configuration_misalignment	POST	DeviceConfigurationMisalignmentEvent	201
device_heartbeat_lost	POST	DeviceHeartbeatLostEvent	201
device_ip_change	POST	DeviceIPChangeEvent	201
device_rtd	POST	DeviceRTDIssueEvent	201
device_snmp	POST	DeviceSNMPEvent	201
device_status_down	POST	DeviceStatusChangeEvent	201
device_status_up	POST	DeviceStatusChangeEvent	201
device_tcp	POST	DeviceTCPEvent	201
monitoring_profile_state_changed	POST	MonitoringProfileStateChanged	201

getAlertProfiles Deprecated (please use getAlertProfiles2)

curl -X GET {baseURL}/public-api/v1/user/{user_id}/alert-profile \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/user/{user_id}/alert-profile',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/user/{user_id}/alert-profile',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/user/{user_id}/alert-profile', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/user/{user_id}/alert-profile',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/user/{user_id}/alert-profile", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /user/{user_id}/alert-profile

Curl

curl -X GET {baseURL}/public-api/v1/user/{user_id}/alert-profile \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
user_id	path	integer(int32)	true	User ID

[
  {
    "description": "string",
    "events": [
      "device_status_up"
    ],
    "id": 0,
    "is_enabled": true,
    "name": "string",
    "tag": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of configured alert profiles	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[AlertProfile]	false	none
» description	string	false	The description of the alert profile
» events	[string]	false	The list of events associated to the profile
» id	integer(int32)	true	The id of the event profile
» is_enabled	boolean	false	true if the event profile is enabled, false otherwise
» name	string	false	The symbolic name associated to the profile
» tag	string	false	A label associated to the profile

Custom Drivers

listCustomDrivers

curl -X GET {baseURL}/public-api/v1/custom-driver \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/custom-driver', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/custom-driver',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/custom-driver", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /custom-driver

Retrieves the list of available Custom Drivers

[
  {
    "code_inspection": {
      "data_saving_functions": [
        "string"
      ],
      "has_independent_variables": true,
      "has_parameters": true,
      "has_table": true
    },
    "description": "string",
    "device_ids": [
      0
    ],
    "id": 0,
    "is_valid": true,
    "minimal_sample_period": 0,
    "name": "string",
    "requires_credentials": true,
    "type": "GENERIC"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of available Custom Drivers	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[CustomDriver]	false	[A Custom Driver that can be applied on devices]
» code_inspection	object	true	Result of the Custom Driver code analysis
»» data_saving_functions	[string]	true	A list of functions of the {CUSTOM_DRIVER} that save data. Only a one of these can be executed on the same device at a time.
»» has_independent_variables	boolean	true	True if the Custom Driver creates independent variables on execution
»» has_parameters	boolean	true	True if the Custom Driver uses parameters during execution
»» has_table	boolean	true	True if the Custom Driver creates a variable table on execution
» description	string	false	Description of the Custom Driver
» device_ids	[integer]	true	List of the device IDs the Custom Driver is applied on
» id	integer(int32)	true	The identifier of the Custom Driver
» is_valid	boolean	true	True if the Custom Driver has valid code, False otherwise
» minimal_sample_period	integer(int32)	true	The minimal sampling interval of the Custom Driver (in seconds)
» name	string	true	Name of the Custom Driver
» requires_credentials	boolean	true	True if the Custom Driver requires credentials to run, False otherwise
» type	string	true	The Custom Driver type. Driver usage differs between types such as data collection and/or available actions

Enumerated Values

Property	Value
type	GENERIC
type	CONFIGURATION_MANAGEMENT

listCustomDriverAssociations

curl -X GET {baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /custom-driver/agent/{agent_id}/association

Retrieves a list of all Custom Driver associations for an agent

Curl

curl -X GET {baseURL}/public-api/v1/custom-driver/agent/{agent_id}/association \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
agent_id	path	integer(int32)	true	Agent ID

[
  {
    "custom_driver_id": 0,
    "device_id": 0,
    "id": 0,
    "last_inspection_time": "2019-08-24T14:15:22Z",
    "parameters": [
      {
        "custom_driver_parameter_id": 0,
        "description": "string",
        "name": "string",
        "value": null,
        "value_type": "STRING"
      }
    ],
    "sample_period": 0,
    "status": "ENABLED",
    "used_variables": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The list of Custom Driver associations	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[CustomDriverAssociation]	false	[An association between a Custom Driver and a device]
» custom_driver_id	integer(int32)	true	The id of the Custom Driver
» device_id	integer(int32)	true	The id of the device the Custom Driver is applied to
» id	integer(int32)	true	The id of the association
» last_inspection_time	string(date-time)	true	The last time (datetime) the device inspection was executed
» parameters	[object]	false	Parameters used in the association
»» custom_driver_parameter_id	integer(int32)	true	The id of the parameter on the driver level
»» description	string	false	Description of the parameter
»» name	string	true	The identifier by which the parameter is called in the driver script
»» value	any	false	Value of the parameter used for the association. In case it is not set on the association level, the Custom Driver default is shown. Empty if the parameter was added to the Custom Driver without a default value after the association was created
»» value_type	string	true	Value type of the parameter. Numbers are treated as floats, list items are treated as strings
» sample_period	integer(int32)	true	The sampling interval of the Custom Driver (in seconds)
» status	string	true	ENABLED: The association is enabled and running DISABLED: The association is disabled due to failure
» used_variables	integer(int32)	true	The number of variables used by this Custom Driver association

Enumerated Values

Property	Value
value_type	STRING
value_type	NUMBER
value_type	LIST
status	ENABLED
status	DISABLED

reEnableCustomDriverAssociations

curl -X POST {baseURL}/public-api/v1/custom-driver/association/re-enable \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/association/re-enable',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/association/re-enable',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/custom-driver/association/re-enable', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/custom-driver/association/re-enable',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/custom-driver/association/re-enable", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /custom-driver/association/re-enable

Re-enable all disabled Custom Drivers for the current user

Curl

curl -X POST {baseURL}/public-api/v1/custom-driver/association/re-enable \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
include_unrecoverable	query	boolean	false	If true, will also re-enable associations that the system has determined unable to recover (e.g. due to missing credentials). Defaults to false.

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

getCustomDriver

curl -X GET {baseURL}/public-api/v1/custom-driver/{custom_driver_id} \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/custom-driver/{custom_driver_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /custom-driver/{custom_driver_id}

Returns details of a Custom Driver

Curl

curl -X GET {baseURL}/public-api/v1/custom-driver/{custom_driver_id} \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
custom_driver_id	path	integer(int32)	true	Custom Driver ID

{
  "actions": [
    {
      "documentation": "string",
      "id": 0,
      "label": "string",
      "line": 0
    }
  ],
  "code": "string",
  "code_inspection": {
    "data_saving_functions": [
      "string"
    ],
    "has_independent_variables": true,
    "has_parameters": true,
    "has_table": true
  },
  "description": "string",
  "errors": [
    {
      "line": 0,
      "message": "string",
      "type": "string"
    }
  ],
  "id": 0,
  "is_valid": true,
  "minimal_sample_period": 0,
  "name": "string",
  "parameters": [
    {
      "default_value": null,
      "description": "string",
      "id": 0,
      "name": "string",
      "value_type": "STRING"
    }
  ],
  "requires_credentials": true,
  "type": "GENERIC"
}

Responses

Status	Meaning	Description	Schema
200	OK	Custom Driver details	CustomDriverDetails

createCustomDriverAssociation

curl -X POST {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "credentials": {
    "password": "string",
    "username": "string"
  },
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ],
  "sample_period": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association

Apply a Custom Driver to a device

{
  "credentials": {
    "password": "string",
    "username": "string"
  },
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ],
  "sample_period": 0
}

Curl

curl -X POST {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/association \ -H 'Content-Type: application/json' \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
custom_driver_id	path	integer(int32)	true	Custom Driver ID
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
body	body	CustomDriverAssociationCreation	false	none

{
  "error": "string",
  "result": 0
}

Responses

Status	Meaning	Description	Schema
201	Created	The outcome of the association	CustomDriverAssociationCreationResult

executeCustomDriverAction

curl -X POST {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "test": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.post('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.post '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id}

Execute a Custom Driver action on an associated device. The agent variables limit for Custom Drivers must not be exceeded.

{
  "test": true
}

Curl

curl -X POST {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/agent/{agent_id}/device/{device_id}/execute/{action_id} \ -H 'Content-Type: application/json' \ -H 'Accept: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
custom_driver_id	path	integer(int32)	true	Custom Driver ID
agent_id	path	integer(int32)	true	Agent ID
device_id	path	integer(int32)	true	Device ID
action_id	path	string	true	Custom Driver Action id. Valid range 1-30 or get-status
body	body	CustomDriverExecutionOptions	false	none

{
  "elapsed": 0,
  "errorMessage": "string",
  "errorType": "string",
  "log": [
    "string"
  ],
  "outcome": "undefined"
}

Responses

Status	Meaning	Description	Schema
200	OK	The outcome of the custom action execution	CustomDriverExecutionResult

deleteCustomDriverAssociation

curl -X DELETE {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id} \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'X-Api-Key': 'API_KEY'
}

r = requests.delete('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.delete '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /custom-driver/{custom_driver_id}/association/{association_id}

Remove a Custom Driver from a device. This irreversibly deletes all variables created by the driver for that device

Curl

curl -X DELETE {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id} \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
custom_driver_id	path	integer(int32)	true	Custom Driver ID
association_id	path	integer(int32)	true	Custom Driver Association ID

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

updateCustomDriverAssociationParameters

curl -X PUT {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id} \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.put('{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.put '{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "{baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /custom-driver/{custom_driver_id}/association/{association_id}

Update the parameters for a Custom Driver association

{
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ]
}

Curl

curl -X PUT {baseURL}/public-api/v1/custom-driver/{custom_driver_id}/association/{association_id} \ -H 'Content-Type: application/json' \ -H 'X-Api-Key: API_KEY'

Parameters

Parameter	In	Type	Required	Description
custom_driver_id	path	integer(int32)	true	Custom Driver ID
association_id	path	integer(int32)	true	Custom Driver Association ID
body	body	CustomDriverAssociationParameterCreation	true	A list of parameters to update

Responses

Status	Meaning	Description	Schema
204	No Content	none	None

assets

listDeviceBaseTypes

curl -X GET {baseURL}/public-api/v1/type/device/base \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/type/device/base',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/type/device/base',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/type/device/base', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/type/device/base',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/type/device/base", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /type/device/base

Returns the device types list

[
  {
    "id": 0,
    "identifier": "string",
    "label": "string",
    "vital": true
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The types list	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DeviceBaseType]	false	[A device type, either set by the user or as identified by the Domotz system]
» id	integer(int32)	false	An unique identifier of the type, referred in the `Device` entity
» identifier	string	false	The name of the type
» label	string	false	A human-readable short description of the type
» vital	boolean	false	Whether a device of this type will be marked as `VITAL` as soon as recognised

listDeviceDetectedTypes

curl -X GET {baseURL}/public-api/v1/type/device/detected \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/type/device/detected',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/type/device/detected',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/type/device/detected', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/type/device/detected',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/type/device/detected", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /type/device/detected

Returns the detected device types list

[
  {
    "capabilities": [
      "string"
    ],
    "id": 0,
    "identifier": "string",
    "label": "string",
    "type_id": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	The types list	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
anonymous	[DetectedDeviceType]	false	[A device type, detected by the Domotz device identification feature]
» capabilities	[string]	false	The features of the device
» id	integer(int32)	false	An unique identifier of the type, referred in the `Device` entity
» identifier	string	false	The name of the type
» label	string	false	A human-readable short description of the type
» type_id	integer(int32)	false	The corresponding `device type`

user

getUser

curl -X GET {baseURL}/public-api/v1/user \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: API_KEY'

var headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

$.ajax({
  url: '{baseURL}/public-api/v1/user',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-Api-Key':'API_KEY'

};

fetch('{baseURL}/public-api/v1/user',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'X-Api-Key': 'API_KEY'
}

r = requests.get('{baseURL}/public-api/v1/user', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Api-Key' => 'API_KEY'
}

result = RestClient.get '{baseURL}/public-api/v1/user',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-Api-Key": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "{baseURL}/public-api/v1/user", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /user

Returns the User information

{
  "id": 0,
  "name": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	The user	User

Schemas

APIUsageInformation

{
  "by_ip": [
    {
      "count": 0,
      "name": "string"
    }
  ],
  "by_key": [
    {
      "count": 0,
      "id": 0,
      "name": "string"
    }
  ],
  "by_resource": [
    {
      "count": 0,
      "name": "string"
    }
  ],
  "concurrent_allowed": 0,
  "daily_limit": 0,
  "daily_usage": 0
}

Information about Domotz API current usage and usage limits

Properties

Name	Type	Required	Description
by_ip	[object]	false	none
» count	integer(int32)	false	The number of calls originated from that IP address
» name	string	false	The IP address
by_key	[object]	false	none
» count	integer(int32)	false	The number of calls done using this key in the last 24 hours
» id	integer(int32)	false	The ID of the API key
» name	string	false	The mnemonic API key name
by_resource	[object]	false	none
» count	integer(int32)	false	The number of calls for the resource
» name	string	false	The base resource name
concurrent_allowed	integer(int32)	false	Number of allowed calls to the API in a minute.
daily_limit	integer(int32)	false	Number of allowed calls to the API in a 24 hours span.
daily_usage	integer(int32)	false	Number of API call performed in the last 24 hours.

AbstractDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  }
}

Base abstract class for all devices

Properties

Name	Type	Required	Description
authentication_status	string	false	When defined the device requires authentication info to perform extended discovery REQUIRED: the device requires authentication, extended discovery is locked PENDING: credentials have been submitted but not verified yet WRONG_CREDENTIALS: device authentication failed AUTHENTICATED: device authentication succeeded
details	object	false	DeviceDetails
» firmware_version	string	false	none
» notes	string	false	none
» room	string	false	none
» serial	string	false	Set to null to reset and allow the automatically discovered serial number to be used for device
» snmp_read_community	string	false	Deprecated. Please use getSNMPAuthentication
» snmp_write_community	string	false	Deprecated. Please use getSNMPAuthentication
» zone	string	false	none
display_name	string	true	none
first_seen_on	string(date-time)	false	none
id	integer(int32)	true	none
importance	string	false	none
main_id	integer(int32)	false	In a clustered configuration, the main device id
os	object	false	DeviceOS
» build	string	false	none
» name	string	false	none
» version	string	false	none
protocol	string	true	none
snmp_status	string	false	Get the status of SNMP service for the device CHECKING: Indicates that Domotz is currently verifying the SNMP status on the device. This is a transient state. NOT_FOUND: This status indicates that the SNMP service could not be found on the device. NOT_AUTHENTICATED: This status occurs when the SNMP service is detected as active, but Domotz is unable to retrieve data from it. This is most likely due to incorrect community strings or credentials. AUTHENTICATED: This status indicates that Domotz is successfully reading SNMP data from the device.
type	object	false	The device type, if recognised by domotz
» detected_id	integer(int32)	false	none
» id	integer(int32)	false	none
» label	string	false	none
user_data	object	false	none
» model	string	false	none
» name	string	false	none
» type	integer(int32)	false	none
» vendor	string	false	none

Enumerated Values

Property	Value
authentication_status	NO_AUTHENTICATION
authentication_status	AUTHENTICATED
authentication_status	PENDING
authentication_status	REQUIRED
authentication_status	WRONG_CREDENTIALS
importance	VITAL
importance	FLOATING
protocol	IP
protocol	DUMMY
protocol	IP_EXTERNAL
snmp_status	CHECKING
snmp_status	NOT_FOUND
snmp_status	NOT_AUTHENTICATED
snmp_status	AUTHENTICATED

ActivityLog

{
  "description": "string",
  "details": {},
  "device_id": 0,
  "timestamp": "2019-08-24T14:15:22Z",
  "type": "note",
  "user": "string"
}

An activity log item

Properties

Name	Type	Required	Description
description	string	true	Description of the event
details	object	false	Additional details of the event
device_id	integer(int32)	false	Device that triggered the event (if applicable)
timestamp	string(date-time)	true	Timestamp of the event
type	string	true	Type of the event
user	string	true	User who triggered the event

Enumerated Values

Property	Value
type	note
type	agent_alert_level_set
type	agent_alert_resume
type	rtd_session_start
type	cresnet_node_reboot
type	device_reboot
type	firmware_update_start
type	applications_terminate
type	configuration_restore
type	factory_reset
type	network_configuration_change
type	custom_driver_execute
type	remote_session_start
type	remote_session_terminate
type	remote_session_limit_reached
type	vpn_session_start
type	vpn_session_terminate
type	chat_started
type	chat_resolved
type	operator_joined
type	operator_left
type	power_on
type	power_off
type	power_cycle
type	camera_snapshot
type	camera_streaming_start
type	configuration_management_status_change

AgentBase

{
  "access_right": {
    "api_enabled": true,
    "granting_user": {
      "name": "user@example.com"
    },
    "status": "OWNED"
  },
  "creation_time": "2019-08-24T14:15:22Z",
  "display_name": "string",
  "id": 0,
  "installation_info": {
    "contract_id": "string",
    "customer_id": "string"
  },
  "licence": {
    "activation_time": "2019-08-24T14:15:22Z",
    "bound_mac_address": "string",
    "code": "string",
    "expiration_time": "2019-08-24T14:15:22Z",
    "id": 0
  },
  "location": {
    "latitude": "string",
    "longitude": "string"
  },
  "organization": {
    "id": 0,
    "name": "string"
  },
  "status": {
    "last_change": "2019-08-24T14:15:22Z",
    "value": "ONLINE"
  },
  "team": {
    "area": {
      "id": 0
    },
    "id": 0,
    "leader_id": 0,
    "name": "string"
  },
  "timezone": "string",
  "version": {
    "agent": "string",
    "package": "string"
  },
  "wan_info": {
    "hostname": "string",
    "ip": "string"
  }
}

Properties

Name	Type	Required	Description
access_right	object	false	none
» api_enabled	boolean	false	If `false` the agent plan doesn't allow for API access: you only can see this agent in the list
» granting_user	object	false	none
»» name	string(email)	false	none
» status	string	false	OWNED: you own this agent PROPOSED: the owner proposed you to access the agent, you can accept or reject the offer GRANTED: you accepted the collaboration request for this agent ASSIGNED: your team leader has given you access to the agent
creation_time	string(date-time)	false	none
display_name	string	true	none
id	integer(int32)	true	none
installation_info	object	false	none
» contract_id	string	false	none
» customer_id	string	false	none
licence	object	false	none
» activation_time	string(date-time)	false	none
» bound_mac_address	string	false	The MAC address of the primary interface of the device the software agent runs on
» code	string	false	none
» expiration_time	string(date-time)	false	none
» id	integer(int32)	false	none
location	object	false	none
» latitude	string	false	none
» longitude	string	false	none
organization	object	false	none
» id	integer(int32)	false	none
» name	string	false	none
status	object	false	none
» last_change	string(date-time)	false	none
» value	string	false	none
team	object	false	The Team and Company Area information, only available for companies
» area	object	false	none
»» id	integer(int32)	false	none
» id	integer(int32)	false	none
» leader_id	integer(int32)	false	none
» name	string	false	none
timezone	string	false	none
version	object	false	none
» agent	string	false	none
» package	string	false	none
wan_info	object	false	none
» hostname	string	false	none
» ip	string	false	none

Enumerated Values

Property	Value
status	OWNED
status	GRANTED
status	PROPOSED
status	ASSIGNED
value	ONLINE
value	OFFLINE

AgentDetail

{
  "access_right": {
    "api_enabled": true,
    "granting_user": {
      "name": "user@example.com"
    },
    "status": "OWNED"
  },
  "creation_time": "2019-08-24T14:15:22Z",
  "display_name": "string",
  "id": 0,
  "installation_info": {
    "contract_id": "string",
    "customer_id": "string"
  },
  "licence": {
    "activation_time": "2019-08-24T14:15:22Z",
    "bound_mac_address": "string",
    "code": "string",
    "expiration_time": "2019-08-24T14:15:22Z",
    "id": 0
  },
  "location": {
    "latitude": "string",
    "longitude": "string"
  },
  "organization": {
    "id": 0,
    "name": "string"
  },
  "status": {
    "last_change": "2019-08-24T14:15:22Z",
    "value": "ONLINE"
  },
  "team": {
    "area": {
      "id": 0
    },
    "id": 0,
    "leader_id": 0,
    "name": "string"
  },
  "timezone": "string",
  "version": {
    "agent": "string",
    "package": "string"
  },
  "wan_info": {
    "hostname": "string",
    "ip": "string"
  },
  "listen_on": "string"
}

Properties

allOf

Name	Type	Required	Description
anonymous	AgentBase	false	none

and

Name	Type	Required	Description
anonymous	object	false	none
» listen_on	string	false	The local IP and port the Domotz Agent software is listening on if online - the last known value otherwise
» location	object	false	none
»» latitude	string	false	none
»» longitude	string	false	none
» wan_info	object	false	none
»» hostname	string	false	none
»» ip	string	false	none

AgentDeviceApplication

{
  "application_id": "string",
  "device_id": "string",
  "first_time_seen": "2019-08-24T14:15:22Z",
  "info": "string",
  "install_date": "2019-08-24T14:15:22Z",
  "install_location": "string",
  "last_modified": "2019-08-24T14:15:22Z",
  "last_update": "2019-08-24T14:15:22Z",
  "name": "string",
  "publisher": "string",
  "version": "string"
}

The list of applications of all devices belonging to the agent

Properties

Name	Type	Required	Description
application_id	string	true	none
device_id	string	true	none
first_time_seen	string(date-time)	true	none
info	string	false	none
install_date	string(date-time)	false	none
install_location	string	false	none
last_modified	string(date-time)	false	none
last_update	string(date-time)	false	none
name	string	false	none
publisher	string	false	none
version	string	false	none

AgentDeviceVariable

{
  "creation_time": "2019-08-24T14:15:22Z",
  "device_id": 0,
  "has_history": true,
  "id": 0,
  "label": "string",
  "metric": "string",
  "path": "string",
  "previous_value": "string",
  "unit": "string",
  "value": "string",
  "value_update_time": "2019-08-24T14:15:22Z"
}

The representation of a device variable

Properties

Name	Type	Required	Description
creation_time	string(date-time)	false	The creation time of the variable
device_id	integer(int32)	true	The ID of the device
has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
id	integer(int32)	true	The ID of the variable
label	string	false	The label
metric	string	false	The metric
path	string	true	The variable path
previous_value	string	false	The previous value of the variable
unit	string	false	The unit of measurement
value	string	false	The variable value
value_update_time	string(date-time)	false	The update time of the variable value

AgentExternalHostScanPolicy

{
  "icmp": {
    "enabled": true
  },
  "tcp_ack": {
    "enabled": true,
    "ports": [
      0
    ]
  },
  "tcp_syn": {
    "enabled": true,
    "ports": [
      0
    ]
  }
}

Properties

Name	Type	Required	Description
icmp	object	false	none
» enabled	boolean	true	Enable/disable this scan method
tcp_ack	object	false	none
» enabled	boolean	true	Enable/disable this scan method. The agent sends a TCP packet with only the acknowledgement (ACK) flag set, and a responding reset (RST) packet from the host reveals its presence.
» ports	[integer]	true	The list of TCP port to be scanned with this method. The list cannot be empty if this method is enabled
tcp_syn	object	false	none
» enabled	boolean	true	Enable or disable this scan method. The agent sends a SYN packet to the target host and waits for a response. If the target responds with a SYN/ACK packet or an RST packet, the host is considered up.
» ports	[integer]	true	The list of TCP port to be scanned with this method. The list cannot be empty if this method is enabled

AgentHistory

{
  "timestamp": "2019-08-24T14:15:22Z",
  "type": "CONNECTION_RECOVERED"
}

Properties

Name	Type	Required	Description
timestamp	string(date-time)	true	The time the sample was reported to Domotz
type	string	true	The agent event type

Enumerated Values

Property	Value
type	CONNECTION_RECOVERED
type	CONNECTION_LOST
type	UP
type	DOWN

AgentIPScanPolicy

{
  "forced_ip_addresses": [
    "string"
  ],
  "forced_ip_ranges": [
    {
      "end": "string",
      "start": "string"
    }
  ]
}

Properties

Name	Type	Required	Description
forced_ip_addresses	[string]	true	The list of IP addresses always checked by the agent. By default the list is empty and the agent performs hosts discovery automatically. The addresses must be expressed in dotted decimal notation and must belong to private networks (see iana-ipv4-special-registry)
forced_ip_ranges	[object]	true	The list of IP address ranges always checked by the agent. By default the list is empty and the agent performs hosts discovery automatically. The addresses must be expressed in dotted decimal notation and must belong to private networks (see iana-ipv4-special-registry)
» end	string	true	192.168.1.10
» start	string	true	192.168.1.1

AgentInterfacesPolicy

{
  "policy": "allow",
  "rules": [
    "string"
  ]
}

Properties

Name	Type	Required	Description
policy	string	true	none
rules	[string]	true	Rules can be expressed as lists of case-insensitive strings representing the names of the interfaces to be matched. The `` wildcard can be used to match variable parts of the interface name. Example: `["eth", "tun0"]`

Enumerated Values

Property	Value
policy	allow
policy	deny

AgentIpConflict

{
  "conflicting_devices": [
    {
      "id": 0,
      "mac": "string"
    }
  ],
  "ip": "string"
}

Properties

Name	Type	Required	Description
conflicting_devices	[object]	false	none
» id	integer(int32)	false	none
» mac	string	false	none
ip	string	false	none

AgentLANChangeEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "dhcp": {
      "new": [
        "string"
      ],
      "old": [
        "string"
      ]
    },
    "dns": {
      "new": [
        "string"
      ],
      "old": [
        "string"
      ]
    },
    "gateway": {
      "new": "string",
      "old": "string"
    }
  },
  "name": "agent_lan_change",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when gateway, DNS servers, DHCP servers change

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	true	The `id` of the `agent`
» dhcp	object	false	none
»» new	[string]	false	none
»» old	[string]	false	none
» dns	object	false	none
»» new	[string]	false	none
»» old	[string]	false	none
» gateway	object	false	none
»» new	string	false	none
»» old	string	false	none
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	agent_lan_change

AgentSecurityIssueEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "value": [
      {
        "port": 0,
        "type": "TCP_OPEN_PORT"
      }
    ]
  },
  "name": "agent_security_issue",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when Domotz detects a security issue

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» value	[object]	false	none
»» port	integer(int32)	false	none
»» type	string	false	none
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
type	TCP_OPEN_PORT
type	UPNP_IGD_FORWARD
type	UPNP_IGD_SERVICE
name	agent_security_issue

AgentSpeedTestEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "status": "SPEED_TEST_ISSUE_DETECTED",
    "threshold": {
      "download": 0,
      "upload": 0
    },
    "value": {
      "download": 0,
      "upload": 0
    }
  },
  "name": "agent_speed_test",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the measured Internet speed goes below the defined threshold

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» status	string	false	none
» threshold	object	false	none
»» download	integer(int32)	false	The configured download threshold
»» upload	integer(int32)	false	The configured upload threshold
» value	object	false	none
»» download	integer(int32)	false	The measured download value
»» upload	integer(int32)	false	The measured upload value
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
status	SPEED_TEST_ISSUE_DETECTED
status	SPEED_TEST_ISSUE_RESOLVED
name	agent_speed_test

AgentStatusEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "value": "UP"
  },
  "name": "agent_status",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the agent connectivity status changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» value	string	false	none
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
value	UP
value	DOWN
name	agent_status

AgentUptime

{
  "agent_id": 0,
  "downtime_intervals": [
    {
      "end": "2019-08-24T14:15:22Z",
      "start": "2019-08-24T14:15:22Z"
    }
  ],
  "online_seconds": 0,
  "total_seconds": 0,
  "uptime": "string"
}

Properties

Name	Type	Required	Description
agent_id	integer(int32)	true	none
downtime_intervals	[object]	false	none
» end	string(date-time)	false	none
» start	string(date-time)	false	none
online_seconds	integer(int32)	true	none
total_seconds	integer(int32)	true	none
uptime	string	true	The uptime percentage of the agent

AgentVPNActiveConnection

{
  "bytes": 0,
  "creation_time": "2019-08-24T14:15:22Z",
  "expiration_time": "2019-08-24T14:15:22Z",
  "id": 0,
  "name": "string",
  "status": "ACTIVE"
}

Properties

Name	Type	Required	Description
bytes	integer(int32)	true	Current VPN connection consumption (bytes)
creation_time	string(date-time)	true	none
expiration_time	string(date-time)	true	none
id	integer(int32)	true	The ID of the VPN connection
name	string	true	The user that started the VPN connection
status	string	true	The status of the vpn connection

Enumerated Values

Property	Value
status	ACTIVE
status	INACTIVE
status	EXPIRED

AgentVPNConnection

{
  "allowed_ip": "string",
  "routing_policy": "global",
  "ttl_hours": 1
}

Properties

Name	Type	Required	Description
allowed_ip	string	true	The only public IP address allowed to access the connection. It will be impossible to use the connection from other IP addresses. You should use your public IP address.
routing_policy	string	true	The traffic routing policy for the VPN connection: - global: All the traffic is routed through the VPN On Demand. More consumption on the Domotz Cloud - local: Only LAN traffic passes through the VPN On Demand. Less consumption on the Domotz Cloud
ttl_hours	integer(int32)	false	The duration in hours of the connection.

Enumerated Values

Property	Value
routing_policy	global
routing_policy	local

AgentVariable

{
  "creation_time": "2019-08-24T14:15:22Z",
  "has_history": true,
  "id": 0,
  "label": "string",
  "metric": "string",
  "path": "string",
  "previous_value": "string",
  "unit": "string",
  "value": "string",
  "value_update_time": "2019-08-24T14:15:22Z"
}

The representation of an agent variable

Properties

Name	Type	Required	Description
creation_time	string(date-time)	false	The creation time of the variable
has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
id	integer(int32)	true	The ID of the variable
label	string	false	The label
metric	string	false	The metric
path	string	true	The variable path
previous_value	string	false	The previous value of the variable
unit	string	false	The unit of measurement
value	string	false	The variable value
value_update_time	string(date-time)	false	The update time of the variable value

AgentWANChangeEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "ip": {
      "new": {
        "address": "string",
        "name": "string"
      },
      "old": {
        "address": "string",
        "name": "string"
      }
    },
    "provider": {
      "new": {
        "country": "string",
        "descr": "string",
        "inetnum": "string",
        "netname": "string"
      },
      "old": {
        "country": "string",
        "descr": "string",
        "inetnum": "string",
        "netname": "string"
      }
    }
  },
  "name": "agent_wan_change",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when ISP or Public IP address changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	true	The `id` of the `agent`
» ip	object	false	none
»» new	object	false	none
»»» address	string	false	none
»»» name	string	false	none
»» old	object	false	none
»»» address	string	false	none
»»» name	string	false	none
»» provider	object	false	none
»»» new	object	false	none
»»»» country	string	false	none
»»»» descr	string	false	none
»»»» inetnum	string	false	none
»»»» netname	string	false	none
»»» old	object	false	none
»»»» country	string	false	none
»»»» descr	string	false	none
»»»» inetnum	string	false	none
»»»» netname	string	false	none
»»» name	string	true	none
»»» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	agent_wan_change

AlertProfile

{
  "description": "string",
  "events": [
    "device_status_up"
  ],
  "id": 0,
  "is_enabled": true,
  "name": "string",
  "tag": "string"
}

Properties

Name	Type	Required	Description
description	string	false	The description of the alert profile
events	[string]	false	The list of events associated to the profile
id	integer(int32)	true	The id of the event profile
is_enabled	boolean	false	true if the event profile is enabled, false otherwise
name	string	false	The symbolic name associated to the profile
tag	string	false	A label associated to the profile

AlertProfileAgentBinding

{
  "alert_profile_id": 0
}

Properties

Name	Type	Required	Description
alert_profile_id	integer(int32)	true	The id of the alert profile

AlertProfileDeviceBinding

{
  "alert_profile_id": 0,
  "device_id": 0
}

Properties

Name	Type	Required	Description
alert_profile_id	integer(int32)	true	The id of the alert profile
device_id	integer(int32)	true	none

AllAgentInterfaces

{
  "attached": [
    {
      "address": "string",
      "mac_address": "string",
      "name": "string",
      "netmask": 0
    }
  ],
  "routed": [
    {
      "address": "string",
      "name": "string",
      "netmask": 0
    }
  ]
}

Properties

Name	Type	Required	Description
attached	[object]	true	none
» address	string	false	none
» mac_address	string	false	none
» name	string	true	none
» netmask	integer(int32)	false	none
routed	[object]	true	none
» address	string	false	none
» name	string	true	none
» netmask	integer(int32)	false	none

Area

{
  "id": 0,
  "name": "string"
}

Represents an area of the Company

Properties

Name	Type	Required	Description
id	integer(int32)	true	The identifier of the Area
name	string	true	The name of the Area

ConnectionConsumption

{
  "current": 0,
  "limit": 0
}

Properties

Name	Type	Required	Description
current	integer(int32)	true	Current connection consumption (bytes)
limit	integer(int32)	true	Maximum connection consumption (bytes)

ConnectionSession

{
  "allowed_ip": "string",
  "expiration": "2019-08-24T14:15:22Z",
  "id": 0,
  "link": "string",
  "port": 0,
  "protocol": "http"
}

Properties

Name	Type	Required	Description
allowed_ip	string	true	The only public IP address allowed to access the connection. It will be impossible to use the connection from other IP addresses. You should use your public IP address.
expiration	string(date-time)	false	The time after which the connection will be closed
id	integer(int32)	true	The unique identifier of the `connection`
link	string	false	Either the link to access the device's HTTP(s) interface in the browser or the host/port coordinates of the proxied TCP port, depending on the protocol (see protocol description in the request)
port	integer(int32)	true	none
protocol	string	true	The protocol wrapped by the connection: - http/https: the `link` field in the reply will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects. If the protocol is `https` the device's certificate will be accepted without checks and its information ignored (our server will act as a proxy). - tcp: the `link` field will be in the form `tcp://{host}:{port}`. Any connection established (e.g. with `telnet` or `ssh`) on these coordinates will be securely forwarded to the requested `port` of the device. - ssh: the `link` field will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects. - rdp: the `link` field will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects.

Enumerated Values

Property	Value
protocol	http
protocol	https
protocol	tcp
protocol	ssh
protocol	rdp

CustomDriver

{
  "code_inspection": {
    "data_saving_functions": [
      "string"
    ],
    "has_independent_variables": true,
    "has_parameters": true,
    "has_table": true
  },
  "description": "string",
  "device_ids": [
    0
  ],
  "id": 0,
  "is_valid": true,
  "minimal_sample_period": 0,
  "name": "string",
  "requires_credentials": true,
  "type": "GENERIC"
}

A Custom Driver that can be applied on devices

Properties

Name	Type	Required	Description
code_inspection	object	true	Result of the Custom Driver code analysis
» data_saving_functions	[string]	true	A list of functions of the {CUSTOM_DRIVER} that save data. Only a one of these can be executed on the same device at a time.
» has_independent_variables	boolean	true	True if the Custom Driver creates independent variables on execution
» has_parameters	boolean	true	True if the Custom Driver uses parameters during execution
» has_table	boolean	true	True if the Custom Driver creates a variable table on execution
description	string	false	Description of the Custom Driver
device_ids	[integer]	true	List of the device IDs the Custom Driver is applied on
id	integer(int32)	true	The identifier of the Custom Driver
is_valid	boolean	true	True if the Custom Driver has valid code, False otherwise
minimal_sample_period	integer(int32)	true	The minimal sampling interval of the Custom Driver (in seconds)
name	string	true	Name of the Custom Driver
requires_credentials	boolean	true	True if the Custom Driver requires credentials to run, False otherwise
type	string	true	The Custom Driver type. Driver usage differs between types such as data collection and/or available actions

Enumerated Values

Property	Value
type	GENERIC
type	CONFIGURATION_MANAGEMENT

CustomDriverAssociation

{
  "custom_driver_id": 0,
  "device_id": 0,
  "id": 0,
  "last_inspection_time": "2019-08-24T14:15:22Z",
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "description": "string",
      "name": "string",
      "value": null,
      "value_type": "STRING"
    }
  ],
  "sample_period": 0,
  "status": "ENABLED",
  "used_variables": 0
}

An association between a Custom Driver and a device

Properties

Name	Type	Required	Description
custom_driver_id	integer(int32)	true	The id of the Custom Driver
device_id	integer(int32)	true	The id of the device the Custom Driver is applied to
id	integer(int32)	true	The id of the association
last_inspection_time	string(date-time)	true	The last time (datetime) the device inspection was executed
parameters	[object]	false	Parameters used in the association
» custom_driver_parameter_id	integer(int32)	true	The id of the parameter on the driver level
» description	string	false	Description of the parameter
» name	string	true	The identifier by which the parameter is called in the driver script
» value	any	false	Value of the parameter used for the association. In case it is not set on the association level, the Custom Driver default is shown. Empty if the parameter was added to the Custom Driver without a default value after the association was created
» value_type	string	true	Value type of the parameter. Numbers are treated as floats, list items are treated as strings
sample_period	integer(int32)	true	The sampling interval of the Custom Driver (in seconds)
status	string	true	ENABLED: The association is enabled and running DISABLED: The association is disabled due to failure
used_variables	integer(int32)	true	The number of variables used by this Custom Driver association

Enumerated Values

Property	Value
value_type	STRING
value_type	NUMBER
value_type	LIST
status	ENABLED
status	DISABLED

CustomDriverAssociationCreation

{
  "credentials": {
    "password": "string",
    "username": "string"
  },
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ],
  "sample_period": 0
}

Properties for associating a Custom Driver and a device

Properties

Name	Type	Required	Description
credentials	object	false	The credentials for the Custom Driver (with scope CUSTOM_DRIVER_MANAGEMENT). Only required if the driver requires credentials, and there are none saved for the device
» password	string	true	password
» username	string	true	username
parameters	[object]	false	A list of parameters to be used for the association. Only required if the Custom Driver uses parameters. Parameters with default values at the driver level can be skipped.
» custom_driver_parameter_id	integer(int32)	true	The id of the parameter on the driver level
» value	any	false	Value of the parameter for the association. Its type can be either a float, a string or a list based on its value_type. The following restrictions apply based on the value type: STRING: maximum 100 characters LIST: maximum 50 items, maximum 100 characters each
sample_period	integer(int32)	false	The sampling interval of the Custom Driver (in seconds). Must be one of [300, 600, 900, 1800, 3600, 7200, 21600, 43200, 86400] and equal to or greater than the minimal_sample_period of the Custom Driver. Default value is the minimal_sample_period of the Custom Driver

CustomDriverAssociationCreationResult

{
  "error": "string",
  "result": 0
}

The outcome of applying a Custom Driver to a device

Properties

Name	Type	Required	Description
error	string	false	Description of the error that occurred. Returned in case of failure.
result	integer(int32)	false	The id of the newly created association. Returned in case of success.

CustomDriverAssociationParameterCreation

{
  "parameters": [
    {
      "custom_driver_parameter_id": 0,
      "value": null
    }
  ]
}

Creation data for multiple association parameters

Properties

Name	Type	Required	Description
parameters	[object]	true	none
» custom_driver_parameter_id	integer(int32)	true	The id of the parameter on the driver level
» value	any	false	Value of the parameter for the association. Its type can be either a float, a string or a list based on its value_type. The following restrictions apply based on the value type: STRING: maximum 100 characters LIST: maximum 50 items, maximum 100 characters each

CustomDriverDetails

{
  "actions": [
    {
      "documentation": "string",
      "id": 0,
      "label": "string",
      "line": 0
    }
  ],
  "code": "string",
  "code_inspection": {
    "data_saving_functions": [
      "string"
    ],
    "has_independent_variables": true,
    "has_parameters": true,
    "has_table": true
  },
  "description": "string",
  "errors": [
    {
      "line": 0,
      "message": "string",
      "type": "string"
    }
  ],
  "id": 0,
  "is_valid": true,
  "minimal_sample_period": 0,
  "name": "string",
  "parameters": [
    {
      "default_value": null,
      "description": "string",
      "id": 0,
      "name": "string",
      "value_type": "STRING"
    }
  ],
  "requires_credentials": true,
  "type": "GENERIC"
}

Detailed information for a Custom Driver that can be applied on devices

Properties

Name	Type	Required	Description
actions	[object]	true	A list of the custom actions that can be executed by this Custom Driver (empty if none exist)
» documentation	string	true	Detailed description of the custom driver action
» id	integer(int32)	true	Identifier of the custom driver action. Used in execution API Values range 1-30 depending on defined actions in the driver code
» label	string	true	The label of the action, shown as the button label in the ui when the driver is applied to a device
» line	integer(int32)	true	Line number of the function declaration for the action
code	string	true	The source code of the driver
code_inspection	object	true	Result of the Custom Driver code analysis
» data_saving_functions	[string]	true	A list of functions of the {CUSTOM_DRIVER} that save data. Only a one of these can be executed on the same device at a time.
» has_independent_variables	boolean	true	True if the Custom Driver creates independent variables on execution
» has_parameters	boolean	true	True if the Custom Driver uses parameters during execution
» has_table	boolean	true	True if the Custom Driver creates a variable table on execution
description	string	false	Description of the Custom Driver
errors	[object]	false	A list of errors in this driver's code. Only returned if the driver's code is invalid and cannot be executed
» line	integer(int32)	false	The line number in the code that raised the error.
» message	string	false	Error message
» type	string	true	Type of the error
id	integer(int32)	true	The identifier of the Custom Driver
is_valid	boolean	true	True if the Custom Driver has valid code, False otherwise
minimal_sample_period	integer(int32)	true	The minimal sampling interval of the Custom Driver (in seconds)
name	string	true	Name of the Custom Driver
parameters	[object]	false	A list of parameters used by this Custom Driver. Only returned if the driver has parameters defined
» default_value	any	false	Default value of the parameter. Its type can be either a float, a string or a list based on its value_type.
» description	string	false	Description of the parameter
» id	integer(int32)	true	Unique id
» name	string	true	The identifier by which the parameter is called in the driver script
» value_type	string	true	Value type of the parameter. Numbers are treated as floats, list items are treated as strings
requires_credentials	boolean	true	True if the Custom Driver requires credentials to run, False otherwise
type	string	true	The Custom Driver type. Driver usage differs between types such as data collection and/or available actions

Enumerated Values

Property	Value
value_type	STRING
value_type	NUMBER
value_type	LIST
type	GENERIC
type	CONFIGURATION_MANAGEMENT

CustomDriverExecutionOptions

{
  "test": true
}

Options provided to a Custom Driver execution command

Properties

Name	Type	Required	Description
test	boolean	false	If false, the Custom Driver variables will be persisted in history. Defaults to true

CustomDriverExecutionResult

{
  "elapsed": 0,
  "errorMessage": "string",
  "errorType": "string",
  "log": [
    "string"
  ],
  "outcome": "undefined"
}

The result of a Custom Driver execution command

Properties

Name	Type	Required	Description
elapsed	integer(int32)	false	The time it took to Execute the Custom Driver Action (in milliseconds)
errorMessage	string	false	Expanded description of the errorType returned in a failed Custom Driver Execution
errorType	string	false	Short name of the error returned with a failed outcome of the Custom Driver Execution
log	[string]	false	List of log messages generated during the Custom Driver Execution
outcome	string	true	Outcome from the Custom Driver Execution

Enumerated Values

Property	Value
outcome	success
outcome	failure
outcome	undefined

DHCPDeviceDiscoverySetting

{
  "dhcp_device_discovery": true
}

Properties

Name	Type	Required	Description
dhcp_device_discovery	boolean	true	When set to 'true', the agent will create devices that initiate DHCP requests even if they fail to obtain an IP address

DetectedDeviceType

{
  "capabilities": [
    "string"
  ],
  "id": 0,
  "identifier": "string",
  "label": "string",
  "type_id": 0
}

A device type, detected by the Domotz device identification feature

Properties

Name	Type	Required	Description
capabilities	[string]	false	The features of the device
id	integer(int32)	false	An unique identifier of the type, referred in the `Device` entity
identifier	string	false	The name of the type
label	string	false	A human-readable short description of the type
type_id	integer(int32)	false	The corresponding `device type`

DeviceApplication

{
  "application_id": "string",
  "first_time_seen": "2019-08-24T14:15:22Z",
  "info": "string",
  "install_date": "2019-08-24T14:15:22Z",
  "install_location": "string",
  "last_modified": "2019-08-24T14:15:22Z",
  "last_update": "2019-08-24T14:15:22Z",
  "name": "string",
  "publisher": "string",
  "version": "string"
}

The list of applications of a device

Properties

Name	Type	Required	Description
application_id	string	true	none
first_time_seen	string(date-time)	true	none
info	string	false	none
install_date	string(date-time)	false	none
install_location	string	false	none
last_modified	string(date-time)	false	none
last_update	string(date-time)	false	none
name	string	false	none
publisher	string	false	none
version	string	false	none

DeviceBaseType

{
  "id": 0,
  "identifier": "string",
  "label": "string",
  "vital": true
}

A device type, either set by the user or as identified by the Domotz system

Properties

Name	Type	Required	Description
id	integer(int32)	false	An unique identifier of the type, referred in the `Device` entity
identifier	string	false	The name of the type
label	string	false	A human-readable short description of the type
vital	boolean	false	Whether a device of this type will be marked as `VITAL` as soon as recognised

DeviceConfigurationChangeEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0
  },
  "name": "device_configuration_change",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the device configuration changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	device_configuration_change

DeviceConfigurationMisalignmentEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0
  },
  "name": "device_configuration_misalignment",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the device configuration becomes different from the startup one

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	device_configuration_misalignment

DeviceConnection

{
  "allowed_ip": "string",
  "port": 0,
  "protocol": "http",
  "ttl_hours": 1
}

Properties

Name	Type	Required	Description
allowed_ip	string	true	The only public IP address allowed to access the connection. It will be impossible to use the connection from other IP addresses. You should use your public IP address.
port	integer(int32)	true	none
protocol	string	true	The protocol wrapped by the connection: - http/https: the `link` field in the reply will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects. If the protocol is `https` the device's certificate will be accepted without checks and its information ignored (our server will act as a proxy). - tcp: the `link` field will be in the form `tcp://{host}:{port}`. Any connection established (e.g. with `telnet` or `ssh`) on these coordinates will be securely forwarded to the requested `port` of the device. - ssh: the `link` field will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects. - rdp: the `link` field will contain an `https` URL. A browser or a similar user agent must be used: the client must have cookies enabled and the capability of following 302 redirects.
ttl_hours	integer(int32)	false	The duration in hours of the connection.

Enumerated Values

Property	Value
protocol	http
protocol	https
protocol	tcp
protocol	ssh
protocol	rdp

DeviceCredentials

{
  "password": "string",
  "scope": "DEVICE_MANAGEMENT",
  "username": "string"
}

Properties

Name	Type	Required	Description
password	string	true	password
scope	string	false	The Scope for the Credentials. Default is 'DEVICE_MANAGEMENT' used for device integrations
username	string	true	username

Enumerated Values

Property	Value
scope	CUSTOM_DRIVER_MANAGEMENT
scope	CONFIGURATION_MANAGEMENT
scope	DEVICE_MANAGEMENT
scope	OS_MANAGEMENT

DeviceDiscoveryEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0
  },
  "name": "agent_device_discovery",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when a new device appears on the network

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	false	The `id` of the `device`
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	agent_device_discovery

DeviceEyeSNMPHistorySample

{
  "enum_value": "string",
  "timestamp": "2019-08-24T14:15:22Z",
  "value": "string"
}

Properties

Name	Type	Required	Description
enum_value	string	false	none
timestamp	string(date-time)	true	The time the sample was reported to Domotz
value	string	true	none

DeviceHeartbeatLostEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0
  },
  "name": "device_heartbeat_lost",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when a device does not respond to a ping

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	device_heartbeat_lost

DeviceHistory

{
  "details": {
    "new_ip": [
      "string"
    ],
    "old_ip": [
      "string"
    ]
  },
  "timestamp": "2019-08-24T14:15:22Z",
  "type": "IP_CHANGE"
}

Properties

Name	Type	Required	Description
details	object	false	none
» new_ip	[string]	false	The new IP addresses
» old_ip	[string]	false	The old IP addresses
timestamp	string(date-time)	true	The time the sample was reported to Domotz
type	string	true	The device event type

Enumerated Values

Property	Value
type	IP_CHANGE
type	CREATED
type	UP
type	DOWN

DeviceIPChangeEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "old_ip_addresses": [
      "string"
    ],
    "value": [
      "string"
    ]
  },
  "name": "device_ip_change",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the device IP address changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
» old_ip_addresses	[string]	false	The list of previous IP addresses
» value	[string]	false	The list of new IP addresses
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	device_ip_change

DeviceInventoryField

{
  "creation_time": "2019-08-24T14:15:22Z",
  "key": "string",
  "value": "string"
}

A device inventory field

Properties

Name	Type	Required	Description
creation_time	string(date-time)	false	none
key	string	true	The name of the field, unique in the Inventory
value	string	true	none

DeviceOutlet

{
  "can_write": true,
  "custom_name": "string",
  "device_id": 0,
  "id": "string",
  "links": [
    0
  ],
  "name": "string",
  "power": "ON"
}

Power outlet of a device

Properties

Name	Type	Required	Description
can_write	boolean	true	True if power actions can be executed on the outlet
custom_name	string	false	Name of the outlet assigned by the user
device_id	integer(int32)	true	Unique identifier of the device the outlet belongs to
id	string	true	Unique identifier of the outlet
links	[integer]	true	List of device ids attached to the outlet
name	string	true	Name of the outlet discovered automatically
power	string	true	The current power state of the outlet

Enumerated Values

Property	Value
power	ON
power	OFF
power	unknown

DeviceOutletUpdate

{
  "custom_name": "string"
}

Outlet update data

Properties

Name	Type	Required	Description
custom_name	string	false	Custom name to assign to the outlet

DevicePowerAction

{
  "cycle": true,
  "off": true,
  "on": true,
  "software_reboot": true
}

Properties

Name	Type	Required	Description
cycle	boolean	false	Indicates that a power cycle on the device is possible. Available if the device is connected to just one PDU.
off	boolean	false	Indicates that the device can be powered off. Available if the device is connected to one or more PDU. In the latter case the operation will be performed on all available PDUs. If there no PDU but there is one POE connection, the operation will still be available through that connection.
on	boolean	false	Indicates that the device can be powered on. Available if the device is connected to one or more PDU. In the latter case the operation will be performed on all available PDUs. If there is no PDU but there is one POE connection, the operation will still available through that connection.
software_reboot	boolean	false	Indicates that software reboot on the device is possible. The operation availability depends on the device.

DeviceRTDHistorySample

{
  "lost_packet_count": 0,
  "max": "string",
  "median": "string",
  "min": "string",
  "sent_packet_count": 0,
  "timestamp": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Description
lost_packet_count	integer(int32)	false	none
max	string	false	none
median	string	false	none
min	string	false	none
sent_packet_count	integer(int32)	false	none
timestamp	string(date-time)	true	The time the sample was reported to Domotz

DeviceRTDIssueEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "status": "RTD_ISSUE_DETECTED",
    "threshold": {
      "latency": 0,
      "packet_loss_percentage": 0
    },
    "value": {
      "latency": 0,
      "packet_loss_percentage": 0
    }
  },
  "name": "device_rtd",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the Round-Trip-Delay values of a device exceeds the defined thresholds

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
» status	string	false	none
» threshold	object	false	none
»» latency	integer(int32)	false	The configured latency threshold
»» packet_loss_percentage	integer(int32)	false	The configured packet loss percentage threshold
» value	object	false	none
»» latency	integer(int32)	false	The current latency value
»» packet_loss_percentage	integer(int32)	false	The current packet loss percentage value
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
status	RTD_ISSUE_DETECTED
status	RTD_ISSUE_RESOLVED
name	device_rtd

DeviceRTDStatistics

{
  "avg_max": "string",
  "avg_median": "string",
  "avg_min": "string",
  "device_id": 0,
  "latest_lost_packet_count": 0,
  "latest_median": "string",
  "latest_sent_packet_count": 0,
  "timestamp": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Description
avg_max	string	false	none
avg_median	string	false	none
avg_min	string	false	none
device_id	integer(int32)	true	none
latest_lost_packet_count	integer(int32)	false	The number of lost packets of the latest collection sample
latest_median	string	false	The median value of the latest collection sample
latest_sent_packet_count	integer(int32)	false	The number of sent packets of the latest collection sample
timestamp	string(date-time)	true	The timestamp of the latest update

DeviceSNMPEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "enum_value": "string",
    "trigger_name": "string",
    "value": "string"
  },
  "name": "device_snmp",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the status of an SNMP value changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
» enum_value	string	false	The current enum value of the SNMP sensor if the OID is of type enum
» trigger_name	string	false	none
» value	string	false	The current value of the SNMP sensor
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	device_snmp

DeviceSnmpCommunity

{
  "read": "string",
  "write": "string"
}

Properties

Name	Type	Required	Description
read	string	true	Defines new read snmp community
write	string	false	Defines new write snmp community (defaults to read community if not used)

DeviceStatusChangeEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "value": "UP"
  },
  "name": "device_status",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the status of a device changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
» value	string	false	none
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
value	UP
value	DOWN
name	device_status

DeviceTCPEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "value": [
      {
        "port": 0,
        "status": "UP"
      }
    ]
  },
  "name": "device_tcp",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when the status of a monitored TCP service changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	true	The `id` of the `device`
» value	[object]	false	none
»» port	integer(int32)	false	none
»» status	string	false	none
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
status	UP
status	DOWN
name	device_tcp

DeviceUptime

{
  "agent_uptime": "string",
  "downtime_intervals": [
    {
      "end": "2019-08-24T14:15:22Z",
      "start": "2019-08-24T14:15:22Z"
    }
  ],
  "online_seconds": 0,
  "total_seconds": 0,
  "uptime": "string"
}

Properties

Name	Type	Required	Description
agent_uptime	string	true	The uptime percentage of the agent
downtime_intervals	[object]	false	none
» end	string(date-time)	false	none
» start	string(date-time)	false	none
online_seconds	integer(int32)	true	none
total_seconds	integer(int32)	true	none
uptime	string	true	The uptime percentage of the device

DeviceVariable

{
  "creation_time": "2019-08-24T14:15:22Z",
  "has_history": true,
  "id": 0,
  "label": "string",
  "metric": "string",
  "path": "string",
  "previous_value": "string",
  "unit": "string",
  "value": "string",
  "value_update_time": "2019-08-24T14:15:22Z"
}

The representation of a device variable

Properties

Name	Type	Required	Description
creation_time	string(date-time)	false	The creation time of the variable
has_history	boolean	true	If true the history of the variable can be retrieved with getVariableHistory
id	integer(int32)	true	The ID of the variable
label	string	false	The label
metric	string	false	The metric
path	string	true	The variable path
previous_value	string	false	The previous value of the variable
unit	string	false	The unit of measurement
value	string	false	The variable value
value_update_time	string(date-time)	false	The update time of the variable value

DomotzEyesUsageInformation

{
  "limit": 0,
  "usage": {
    "snmp": 0,
    "tcp": 0,
    "total": 0
  }
}

Information about Domotz Sensors current usage and limits

Properties

Name	Type	Required	Description
limit	integer(int32)	false	Number of allowed Domotz Sensors for the agent
usage	object	false	none
» snmp	integer(int32)	false	Number of configured Domotz Sensors of type `snmp` on the agent.
» tcp	integer(int32)	false	Number of configured Domotz Sensors of type `tcp` on the agent.
» total	integer(int32)	false	Number of configured Domotz Sensors on the agent.

DomotzMetricUsageInformation

{
  "limit": 0,
  "usage": {
    "custom_driver": 0,
    "snmp": 0,
    "tcp": 0,
    "total": 0
  }
}

Information about Domotz Sensors current usage and limits

Properties

Name	Type	Required	Description
limit	integer(int32)	false	Number of allowed Domotz Sensors for the agent
usage	object	false	none
» custom_driver	integer(int32)	false	Number of configured Domotz Sensors of type `custom driver` on the agent.
» snmp	integer(int32)	false	Number of configured Domotz Sensors of type `snmp` on the agent.
» tcp	integer(int32)	false	Number of configured Domotz Sensors of type `tcp` on the agent.
» total	integer(int32)	false	Number of configured Domotz Sensors on the agent.

DummyDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  }
}

Properties

allOf

Name	Type	Required	Description
anonymous	AbstractDevice	false	Base abstract class for all devices

and

Name	Type	Required	Description
anonymous	object	false	A device that has no network access whatsoever and cannot be discovered or interacted with by the agent. A user can create a Dummy Device to attach it to a power outlet so that it is easier to remember which port controls the device

ExternalHost

{
  "host": "string",
  "name": "string"
}

Properties

Name	Type	Required	Description
host	string	true	Hostname or IP Address
name	string	true	Device Name

ExternalIpDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  },
  "agent_reachable": true,
  "grace_period": 0,
  "ip_addresses": [
    "string"
  ],
  "last_status_change": "2019-08-24T14:15:22Z",
  "model": "string",
  "open_ports": {
    "tcp": [
      0
    ],
    "udp": [
      0
    ]
  },
  "status": "ONLINE",
  "vendor": "string",
  "names": {
    "host": "string",
    "inspection": "string"
  }
}

Properties

allOf

Name	Type	Required	Description
anonymous	IpDevice	false	none

and

Name	Type	Required	Description
anonymous	object	false	A device added by the means of 'Advanced Monitoring': it is an IP device manually added by the user, no discoveries are done over it, just periodical ping to see whether it is reachable
» names	object	false	none
»» host	string	false	none
»» inspection	string	false	none

FeatureDiscoveryEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "feature": "mib_discovery",
    "value": {
      "data": {}
    }
  },
  "name": "agent_feature_discovery",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when a new feature is discovered on a device

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» agent_id	integer(int32)	false	The `id` of the `agent`
» device	AbstractDevice	false	Base abstract class for all devices
» device_id	integer(int32)	false	The `id` of the `device`
» feature	string	false	The discovered feature
» value	object	false	none
»» data	object	false	none
» name	string	true	none
» timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
feature	mib_discovery
name	agent_feature_discovery

InventoryField

{
  "label": "string",
  "creation_time": "2019-08-24T14:15:22Z",
  "defined_by_user": 0,
  "key": "string"
}

Properties

allOf

Name	Type	Required	Description
anonymous	WriteInventoryField	false	DTO Used for creating/updating Inventory fields

and

Name	Type	Required	Description
anonymous	object	false	DTO Returned by the API describing an Inventory Field
» creation_time	string(date-time)	false	none
» defined_by_user	integer(int32)	false	The `id` of the user that defined the inventory field - if different from your id, this field can't be deleted or changed
» key	string	true	The name of the field, unique in the Inventory

IpDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  },
  "agent_reachable": true,
  "grace_period": 0,
  "ip_addresses": [
    "string"
  ],
  "last_status_change": "2019-08-24T14:15:22Z",
  "model": "string",
  "open_ports": {
    "tcp": [
      0
    ],
    "udp": [
      0
    ]
  },
  "status": "ONLINE",
  "vendor": "string"
}

Properties

allOf

Name	Type	Required	Description
anonymous	AbstractDevice	false	Base abstract class for all devices

and

Name	Type	Required	Description
anonymous	object	false	Base abstract class for all IP devices
» agent_reachable	boolean	false	When `true` the device is reachable by the agent over an IP network. When `false` Domotz knows about the status of the device by the means of another source e.g. a third party controller. This field is significant only when the status of the device is `ONLINE` and its value is `false` because it means that even if the IP device is up and running, many features aren't allowed, such as the direct connection or the TCP services monitoring.
» grace_period	integer(int32)	false	The number of seconds a device must be unreachable before being declared DOWN
» ip_addresses	[string]	false	none
» last_status_change	string(date-time)	false	none
» model	string	false	none
» open_ports	object	false	The list of TCP and UDP open ports. Domotz scans a subset of all the ports, visit the user guide for more details.
»» tcp	[integer]	false	none
»» udp	[integer]	false	none
» status	string	false	none
» vendor	string	false	none

Enumerated Values

Property	Value
status	ONLINE
status	OFFLINE
status	DOWN
status	HIDDEN

LocalIpDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  },
  "agent_reachable": true,
  "grace_period": 0,
  "ip_addresses": [
    "string"
  ],
  "last_status_change": "2019-08-24T14:15:22Z",
  "model": "string",
  "open_ports": {
    "tcp": [
      0
    ],
    "udp": [
      0
    ]
  },
  "status": "ONLINE",
  "vendor": "string",
  "hw_address": "string",
  "is_jammed": true,
  "names": {
    "bonjour": "string",
    "dhcp": "string",
    "host": "string",
    "inspection": "string",
    "netbios": "string",
    "snmp": "string",
    "upnp": "string",
    "zeroconf": "string"
  }
}

Properties

allOf

Name	Type	Required	Description
anonymous	IpDevice	false	none

and

Name	Type	Required	Description
anonymous	object	false	Standard device, automatically discovered in the local IP network of the agent.
» hw_address	string	false	MAC Address
» is_jammed	boolean	false	When true, the Domotz Agent is blocking the device to access the Internet. The device can still reach every other device in the local network
» names	object	false	none
»» bonjour	string	false	none
»» dhcp	string	false	none
»» host	string	false	none
»» inspection	string	false	none
»» netbios	string	false	none
»» snmp	string	false	none
»» upnp	string	false	none
»» zeroconf	string	false	none

MibDiscoveryEvent

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "agent_id": 0,
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "device_id": 0,
    "feature": "mib_discovery",
    "value": {
      "data": {
        "mib": [
          "string"
        ]
      }
    }
  },
  "name": "agent_feature_discovery",
  "timestamp": "2019-08-24T14:15:22Z"
}

Properties

allOf

Name	Type	Required	Description
anonymous	FeatureDiscoveryEvent	false	Triggered when a new feature is discovered on a device

and

Name	Type	Required	Description
anonymous	object	false	Triggered when a new feature MIB is discovered on a device
» data	object	false	none
»» agent	AgentBase	false	none
»» device	AbstractDevice	false	Base abstract class for all devices
»» value	object	false	none
»»» data	object	false	none
»»»» mib	[string]	false	The discovered MIB

MonitoringProfileStateChanged

{
  "data": {
    "agent": {
      "access_right": {
        "api_enabled": true,
        "granting_user": {
          "name": "user@example.com"
        },
        "status": "OWNED"
      },
      "creation_time": "2019-08-24T14:15:22Z",
      "display_name": "string",
      "id": 0,
      "installation_info": {
        "contract_id": "string",
        "customer_id": "string"
      },
      "licence": {
        "activation_time": "2019-08-24T14:15:22Z",
        "bound_mac_address": "string",
        "code": "string",
        "expiration_time": "2019-08-24T14:15:22Z",
        "id": 0
      },
      "location": {
        "latitude": "string",
        "longitude": "string"
      },
      "organization": {
        "id": 0,
        "name": "string"
      },
      "status": {
        "last_change": "2019-08-24T14:15:22Z",
        "value": "ONLINE"
      },
      "team": {
        "area": {
          "id": 0
        },
        "id": 0,
        "leader_id": 0,
        "name": "string"
      },
      "timezone": "string",
      "version": {
        "agent": "string",
        "package": "string"
      },
      "wan_info": {
        "hostname": "string",
        "ip": "string"
      }
    },
    "details": {},
    "device": {
      "authentication_status": "NO_AUTHENTICATION",
      "details": {
        "firmware_version": "string",
        "notes": "string",
        "room": "string",
        "serial": "string",
        "snmp_read_community": "string",
        "snmp_write_community": "string",
        "zone": "string"
      },
      "display_name": "string",
      "first_seen_on": "2019-08-24T14:15:22Z",
      "id": 0,
      "importance": "VITAL",
      "main_id": 0,
      "os": {
        "build": "string",
        "name": "string",
        "version": "string"
      },
      "protocol": "IP",
      "snmp_status": "CHECKING",
      "type": {
        "detected_id": 0,
        "id": 0,
        "label": "string"
      },
      "user_data": {
        "model": "string",
        "name": "string",
        "type": 0,
        "vendor": "string"
      }
    },
    "metric": "string",
    "monitoring_profile": {
      "name": "string"
    },
    "state": {
      "current": "string",
      "previous": "string"
    },
    "value": {
      "current": {},
      "previous": {}
    },
    "variable": {
      "creation_time": "2019-08-24T14:15:22Z",
      "has_history": true,
      "id": 0,
      "label": "string",
      "metric": "string",
      "path": "string",
      "previous_value": "string",
      "unit": "string",
      "value": "string",
      "value_update_time": "2019-08-24T14:15:22Z"
    }
  },
  "name": "monitoring_profile_state_changed",
  "timestamp": "2019-08-24T14:15:22Z"
}

Triggered when a monitoring profile state changes

Properties

Name	Type	Required	Description
data	object	false	none
» agent	AgentBase	false	none
» details	object	false	none
» device	AbstractDevice	false	Base abstract class for all devices
» metric	string	true	none
» monitoring_profile	object	false	none
»» name	string	true	none
» state	object	false	none
»» current	string	false	none
»» previous	string	false	none
» value	object	false	none
»» current	object	false	none
»» previous	object	false	none
» variable	DeviceVariable	false	The representation of a device variable
name	string	true	none
timestamp	string(date-time)	true	The timestamp of the event

Enumerated Values

Property	Value
name	monitoring_profile_state_changed

NetworkSpeedSample

{
  "timestamp": "2019-08-24T14:15:22Z",
  "values": [
    0
  ]
}

A Network Speed Sample is the result of the measurement of the Internet download and upload speed, in bits per second, taken by the Agent

Properties

Name	Type	Required	Description
timestamp	string(date-time)	false	The time the sample was reported to Domotz
values	[integer]	false	A pair of values: the download and upload speed, in Bit Per Seconds (bps), as measured by the Agent

NetworkTopology

{
  "edges": [
    {
      "from": 0,
      "to": 0
    }
  ]
}

Properties

Name	Type	Required	Description
edges	[object]	true	The list of edges. Each item contains the IDs of the connected devices.
» from	integer(int32)	true	none
» to	integer(int32)	true	none

RoutedNetwork

{
  "address": "string",
  "name": "string",
  "netmask": 0
}

Properties

Name	Type	Required	Description
address	string	true	none
name	string	true	none
netmask	integer(int32)	true	none

SNMPDomotzAgentEye

{
  "category": "OTHER",
  "device_id": 0,
  "id": 0,
  "name": "string",
  "oid": "string",
  "value_type": "STRING"
}

Information about a configured SNMP Domotz Sensor

Properties

Name	Type	Required	Description
category	string	true	The category of the OID
device_id	integer(int32)	false	The unique identifier of the device
id	integer(int32)	true	The ID of the SNMP Domotz Sensor
name	string	true	The name of the Domotz Sensors
oid	string	true	The OID string
value_type	string	true	The type of the OID

Enumerated Values

Property	Value
category	OTHER
category	CONSUMABLE
category	CPU
category	DISK_SPACE
category	MEMORY
category	NETWORK_TRAFFIC
category	TEMPERATURE
value_type	STRING
value_type	NUMERIC
value_type	ENUM

SNMPDomotzAuthentication

{
  "authentication_key": "string",
  "authentication_protocol": "MD5",
  "encryption_key": "string",
  "encryption_protocol": "DES",
  "snmp_read_community": "string",
  "snmp_write_community": "string",
  "username": "string",
  "version": "V2"
}

The SNMP authentication setting of a device

Properties

Name	Type	Required	Description
authentication_key	string	false	none
authentication_protocol	string	false	The SNMP authentication protocol
encryption_key	string	false	none
encryption_protocol	string	false	The SNMP encryption protocol
snmp_read_community	string	false	none
snmp_write_community	string	false	none
username	string	false	none
version	string	true	The configured SNMP version

Enumerated Values

Property	Value
authentication_protocol	MD5
authentication_protocol	SHA
authentication_protocol	SHA-224
authentication_protocol	SHA-256
authentication_protocol	SHA-384
authentication_protocol	SHA-512
encryption_protocol	DES
encryption_protocol	AES
encryption_protocol	AES-256B
encryption_protocol	AES-256R
version	V2
version	V1
version	V3_AUTH_PRIV
version	V3_NO_AUTH
version	V3_AUTH_NO_PRIV

SNMPDomotzEye

{
  "category": "OTHER",
  "device_id": 0,
  "id": 0,
  "last_update": "2019-08-24T14:15:22Z",
  "latest_enum_value": "string",
  "latest_value": "string",
  "name": "string",
  "oid": "string",
  "value_type": "STRING"
}

Information about a configured SNMP Domotz Sensor

Properties

Name	Type	Required	Description
category	string	true	The category of the OID
device_id	integer(int32)	false	The unique identifier of the device
id	integer(int32)	true	The ID of the SNMP Domotz Sensor
last_update	string(date-time)	true	The timestamp of the latest update
latest_enum_value	string	false	The enum value retrieved on the OID
latest_value	string	true	The value retrieved on the OID
name	string	true	The name of the Domotz Sensors
oid	string	true	The OID string
value_type	string	true	The type of the OID

Enumerated Values

Property	Value
category	OTHER
category	CONSUMABLE
category	CPU
category	DISK_SPACE
category	MEMORY
category	NETWORK_TRAFFIC
category	TEMPERATURE
value_type	STRING
value_type	NUMERIC
value_type	ENUM

SNMPDomotzEyeCreation

{
  "category": "OTHER",
  "name": "string",
  "oid": "string",
  "value_type": "STRING"
}

SNMP Domotz Sensor Data

Properties

Name	Type	Required	Description
category	string	true	The category of the OID
name	string	true	The name of the Domotz Sensors
oid	string	true	The OID string
value_type	string	true	The type of the OID

Enumerated Values

Property	Value
category	OTHER
category	CONSUMABLE
category	CPU
category	DISK_SPACE
category	MEMORY
category	NETWORK_TRAFFIC
category	TEMPERATURE
value_type	STRING
value_type	NUMERIC
value_type	ENUM

SNMPDomotzEyeTrigger

{
  "alert": {
    "email": true,
    "mobile": true
  },
  "creation_time": "2019-08-24T14:15:22Z",
  "function_id": 0,
  "id": 0,
  "name": "string",
  "operands": [
    "string"
  ]
}

Information about a trigger

Properties

Name	Type	Required	Description
alert	object	false	The alerts details
» email	boolean	false	True if the email alert is active
» mobile	boolean	false	True if the mobile alert is active
creation_time	string(date-time)	false	none
function_id	integer(int32)	true	The unique identifier of the function assigned to the trigger
id	integer(int32)	true	The unique identifier of the SNMP Trigger
name	string	true	The name of the trigger
operands	[string]	true	The operands for the function

SNMPDomotzEyeTriggerFunction

{
  "cardinality": 0,
  "id": 0,
  "name": "string",
  "value_types": "STRING"
}

Information about a trigger function

Properties

Name	Type	Required	Description
cardinality	integer(int32)	true	The number of arguments of the function
id	integer(int32)	true	The unique identifier of the SNMP Trigger function
name	string	true	The name of the function
value_types	string	true	The type of the operands

Enumerated Values

Property	Value
value_types	STRING
value_types	NUMERIC
value_types	ENUM

SNMPDomotzSnmpTriggerAlertCreation

{}

SNMP Trigger Alert

Properties

None

SNMPDomotzSnmpTriggerCreation

{
  "function_id": 0,
  "name": "string",
  "operands": [
    "string"
  ]
}

SNMP Trigger

Properties

Name	Type	Required	Description
function_id	integer(int32)	true	The unique identifier of the sensor function
name	string	true	The name of the trigger
operands	[string]	true	The operands for the function

SubnetIpDevice

{
  "authentication_status": "NO_AUTHENTICATION",
  "details": {
    "firmware_version": "string",
    "notes": "string",
    "room": "string",
    "serial": "string",
    "snmp_read_community": "string",
    "snmp_write_community": "string",
    "zone": "string"
  },
  "display_name": "string",
  "first_seen_on": "2019-08-24T14:15:22Z",
  "id": 0,
  "importance": "VITAL",
  "main_id": 0,
  "os": {
    "build": "string",
    "name": "string",
    "version": "string"
  },
  "protocol": "IP",
  "snmp_status": "CHECKING",
  "type": {
    "detected_id": 0,
    "id": 0,
    "label": "string"
  },
  "user_data": {
    "model": "string",
    "name": "string",
    "type": 0,
    "vendor": "string"
  },
  "agent_reachable": true,
  "grace_period": 0,
  "ip_addresses": [
    "string"
  ],
  "last_status_change": "2019-08-24T14:15:22Z",
  "model": "string",
  "open_ports": {
    "tcp": [
      0
    ],
    "udp": [
      0
    ]
  },
  "status": "ONLINE",
  "vendor": "string",
  "names": {
    "bonjour": "string",
    "host": "string",
    "inspection": "string",
    "snmp": "string",
    "upnp": "string"
  }
}

Properties

allOf

Name	Type	Required	Description
anonymous	IpDevice	false	none

and

Name	Type	Required	Description
anonymous	object	false	A device automatically discovered by the agent that exists in an IP subnet defined by the user. The agent reaches the device through a Level 3 switch or similar device, so it cannot get the MAC address or other level 2 information, such as DHCP lease data
» names	object	false	none
»» bonjour	string	false	none
»» host	string	false	none
»» inspection	string	false	none
»» snmp	string	false	none
»» upnp	string	false	none

TCPDomotzEye

{
  "device_id": 0,
  "id": 0,
  "last_update": "2019-08-24T14:15:22Z",
  "port": 0,
  "status": "UP"
}

Information about a configured TCP Domotz Sensor

Properties

Name	Type	Required	Description
device_id	integer(int32)	false	The unique identifier of the device
id	integer(int32)	true	The ID of the TCP Domotz Sensor
last_update	string(date-time)	true	The timestamp of the latest update
port	integer(int32)	true	The port number
status	string	true	The status of the TCP service

Enumerated Values

Property	Value
status	UP
status	DOWN

TCPDomotzEyeCreation

{
  "port": 0
}

TCP Domotz Sensor Data

Properties

Name	Type	Required	Description
port	integer(int32)	true	The port number

Team

{
  "id": 0,
  "name": "string"
}

Represents a team of the Company

Properties

Name	Type	Required	Description
id	integer(int32)	true	The identifier of the Team
name	string	true	The name of the Team

TeamCreation

{
  "leader": {
    "details": {
      "display_name": "string"
    },
    "name": "string",
    "password": "string"
  },
  "name": "string"
}

Team Creation under specified Area

Properties

Name	Type	Required	Description
leader	object	true	The Team Leader
» details	object	true	The Team Leader's details
»» display_name	string	true	The Team Leader's display name
» name	string	true	The Team Leader's name
» password	string	true	The Team Leader's password
name	string	true	The Team's name

User

{
  "id": 0,
  "name": "string"
}

Properties

Name	Type	Required	Description
id	integer(int32)	false	none
name	string	false	none

VariableHistorySample

{
  "timestamp": "2019-08-24T14:15:22Z",
  "value": "string"
}

Properties

Name	Type	Required	Description
timestamp	string(date-time)	true	The time the sample was reported to Domotz
value	string	true	The sample value

WriteInventoryField

{
  "label": "string"
}

DTO Used for creating/updating Inventory fields

Properties

Name	Type	Required	Description
label	string	true	A detailed description of the field, for documentation