Domotz Public API v1.0.2
Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.
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
Code samples
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) |
Example responses
200 Response
[
{
"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,
"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"
},
"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"
}
}
]
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 |
|
» creation_time | string(date-time) | false | none |
» display_name | string | true | none |
» id | integer(int32) | true | 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 |
» 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 |
Enumerated Values
Property | Value |
---|---|
status | OWNED |
status | GRANTED |
status | PROPOSED |
status | ASSIGNED |
value | ONLINE |
value | OFFLINE |
countAgents
Code samples
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
Code samples
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
Code samples
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 |
Example responses
200 Response
{
"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,
"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"
},
"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"
},
"listen_on": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | The agent | AgentDetail |
getConnectionConsumption
Code samples
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 |
Example responses
200 Response
{
"current": 0,
"limit": 0
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | none | ConnectionConsumption |
getAgentVPNActiveConnections
Code samples
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 |
Example responses
200 Response
[
{
"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 |
actions
createAgentVPNConnection
Code samples
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"
}';
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
Body parameter
{
"allowed_ip": "string",
"routing_policy": "global"
}
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 |
Example responses
201 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
201 | Created | OpenVPN Configuration file content | string |
deleteAgentVPNConnection
Code samples
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 |
session_id | path | integer(int32) | true | Session ID |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
connectToDevice
Code samples
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"
}';
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
Body parameter
{
"allowed_ip": "string",
"port": 0,
"protocol": "http"
}
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 |
Example responses
201 Response
{
"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
Code samples
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
Code samples
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 |
Example responses
200 Response
[
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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 | AUTHENTICATED |
authentication_status | NO_AUTHENTICATION |
authentication_status | PENDING |
authentication_status | REQUIRED |
authentication_status | WRONG_CREDENTIALS |
importance | VITAL |
importance | FLOATING |
protocol | IP |
protocol | DUMMY |
protocol | IP_EXTERNAL |
status | ONLINE |
status | OFFLINE |
status | DOWN |
status | HIDDEN |
deleteDevice
Code samples
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
Code samples
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 |
Example responses
200 Response
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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 | AUTHENTICATED |
authentication_status | NO_AUTHENTICATION |
authentication_status | PENDING |
authentication_status | REQUIRED |
authentication_status | WRONG_CREDENTIALS |
importance | VITAL |
importance | FLOATING |
protocol | IP |
protocol | DUMMY |
protocol | IP_EXTERNAL |
status | ONLINE |
status | OFFLINE |
status | DOWN |
status | HIDDEN |
getDevicePowerActions
Code samples
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 |
Example responses
200 Response
{
"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
Code samples
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 |
setCredentials
Code samples
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",
"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
Body parameter
{
"password": "string",
"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 |
getSNMPAuthentication
Code samples
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 |
Example responses
200 Response
{
"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
Code samples
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.
Body parameter
{
"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
Code samples
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
Body parameter
{
"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
Code samples
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
Code samples
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
Body parameter
"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 |
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 |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
metrics
getAgentRTDStats
Code samples
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 |
Example responses
200 Response
[
{
"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
Code samples
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 |
Example responses
200 Response
[
{
"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
Code samples
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 |
Example responses
200 Response
[
{
"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 |
getAgentStatusHistory
Code samples
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 |
Example responses
200 Response
[
{
"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
Code samples
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 |
Example responses
200 Response
[
{
"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 |
eyes
listEyesSNMP
Code samples
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 Eyes
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 |
Example responses
200 Response
[
{
"category": "OTHER",
"id": 0,
"last_update": "2019-08-24T14:15:22Z",
"latest_value": "string",
"name": "string",
"oid": "string",
"value_type": "STRING"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | The list of configured SNMP Domotz Eyes 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 Eye] |
» category | string | true | The category of the OID |
» id | integer(int32) | true | The unique identifier of the SNMP Domotz Eye |
» last_update | string(date-time) | true | The timestamp of the latest update |
» latest_value | string | true | The value retrieved on the OID |
» name | string | true | The name of the Domotz Eyes |
» 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 |
createEyeSNMP
Code samples
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 Eyes
Body parameter
{
"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
Code samples
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 Eye
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 Eye ID |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
listEyesSNMPTriggerFunction
Code samples
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 Eyes
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 Eye ID |
Example responses
200 Response
[
{
"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 |
getEyesSNMPHistory
Code samples
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 Eyes 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 Eye 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 |
Example responses
200 Response
[
{
"timestamp": "2019-08-24T14:15:22Z",
"value": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | The list of SNMP Domotz Eyes samples | Inline |
Response Schema
Status Code 200
Name | Type | Required | Description |
---|---|---|---|
anonymous | [DeviceEyeSNMPHistorySample] | false | none |
» timestamp | string(date-time) | true | The time the sample was reported to Domotz |
» value | string | true | none |
listEyesSNMPTrigger
Code samples
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 Eye ID |
Example responses
200 Response
[
{
"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 |
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
Code samples
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.
Body parameter
{
"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 Eye ID |
body | body | SNMPDomotzSnmpTriggerCreation | true | none |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
201 | Created | none | None |
deleteEyeSNMPTrigger
Code samples
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 Eye ID |
trigger_id | path | integer(int32) | true | SNMP Eye Trigger ID |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
deleteEyeSNMPTriggerAlert
Code samples
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 Eye ID |
trigger_id | path | integer(int32) | true | SNMP Eye Trigger ID |
medium_name | path | string | true | the name of the medium |
Enumerated Values
Parameter | Value |
---|---|
medium_name | |
medium_name | mobile |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
createEyeSNMPTriggerAlert
Code samples
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
Body parameter
{}
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 Eye ID |
trigger_id | path | integer(int32) | true | SNMP Eye Trigger ID |
medium_name | path | string | true | the name of the medium |
body | body | SNMPDomotzSnmpTriggerAlertCreation | true | none |
Enumerated Values
Parameter | Value |
---|---|
medium_name | |
medium_name | mobile |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
201 | Created | none | None |
listEyesTCP
Code samples
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 Eyes
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 |
Example responses
200 Response
[
{
"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 Eyes 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 Eye] |
» id | integer(int32) | true | The unique identifier of the TCP Domotz Eye |
» 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
Code samples
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 Eyes
Body parameter
{
"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
Code samples
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 Eye
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 Eye ID |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
204 | No Content | none | None |
eyesUsageInfo
Code samples
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 Eyes 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 |
Example responses
200 Response
{
"limit": 0,
"usage": {
"snmp": 0,
"tcp": 0,
"total": 0
}
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | A data structure containing information about current Domotz Eyes usage and limits | DomotzEyesUsageInformation |
multimedia
onvifSnapshot
Code samples
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 |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | A binary image | string |
company
moveAgent
Code samples
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
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
Code samples
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
Example responses
200 Response
[
{
"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
Code samples
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
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 |
Example responses
200 Response
[
{
"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
Code samples
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
Body parameter
{
"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
getAgentAlertProfile
Code samples
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 |
Example responses
200 Response
[
{
"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
Code samples
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 |
Example responses
200 Response
[
{
"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
Code samples
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
Code samples
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_security_issue | POST | AgentSecurityIssueEvent | 201 |
agent_speed_test | POST | AgentSpeedTestEvent | 201 |
agent_status | POST | AgentStatusEvent | 201 |
unbindAlertProfileFromDevice
Code samples
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
Code samples
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 | POST | DeviceStatusChangeEvent | 201 |
device_tcp | POST | DeviceTCPEvent | 201 |
getAlertProfiles
Code samples
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
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)
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 |
Example responses
200 Response
[
{
"description": "string",
"events": [
"device_status"
],
"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 |
meta
apiUsageInfo
Code samples
curl -X GET {baseURL}/public-api/v1/meta/usage \
-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/meta/usage',
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/meta/usage',
{
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/meta/usage', 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/meta/usage',
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/meta/usage", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /meta/usage
Retrieves information about API usage and limits
Example responses
200 Response
{
"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
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | A data structure containing information about current API usage and usage limits | APIUsageInformation |
assets
listDeviceBaseTypes
Code samples
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
Example responses
200 Response
[
{
"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
Code samples
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
Example responses
200 Response
[
{
"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
Code samples
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
Example responses
200 Response
{
"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": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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
|
details | object | false | DeviceDetails |
» room | string | false | none |
» 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 |
protocol | string | true | none |
type | object | false | The device type, if recognised by domotz |
» detected_id | integer(int32) | false | none |
» id | integer(int32) | 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 | AUTHENTICATED |
authentication_status | NO_AUTHENTICATION |
authentication_status | PENDING |
authentication_status | REQUIRED |
authentication_status | WRONG_CREDENTIALS |
importance | VITAL |
importance | FLOATING |
protocol | IP |
protocol | DUMMY |
protocol | IP_EXTERNAL |
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,
"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"
},
"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"
}
}
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 |
|
creation_time | string(date-time) | false | none |
display_name | string | true | none |
id | integer(int32) | true | 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 |
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 |
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,
"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"
},
"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"
},
"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 |
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 |
AgentSecurityIssueEvent
{
"data": {
"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_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_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_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_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_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 |
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"
}
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. For http and https it is safe, since if you keep the connection link secret nobody will access the device. For tcp it is not recommended because a random port scan on our servers may allow an hostile actor to use the connection, accessing the device's tcp port as if it was in the agent's network. |
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 |
Enumerated Values
Property | Value |
---|---|
routing_policy | global |
routing_policy | local |
AlertProfile
{
"description": "string",
"events": [
"device_status"
],
"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 |
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. For http and https it is safe, since if you keep the connection link secret nobody will access the device. For tcp it is not recommended because a random port scan on our servers may allow an hostile actor to use the connection, accessing the device's tcp port as if it was in the agent's network. |
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 |
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 |
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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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"
}
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. For http and https it is safe, since if you keep the connection link secret nobody will access the device. For tcp it is not recommended because a random port scan on our servers may allow an hostile actor to use the connection, accessing the device's tcp port as if it was in the agent's network. |
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 |
DeviceCredentials
{
"password": "string",
"username": "string"
}
Properties
Name | Type | Required | Description |
---|---|---|---|
password | string | true | password |
username | string | true | username |
DeviceDiscoveryEvent
{
"data": {
"agent_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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
{
"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 | none |
DeviceHeartbeatLostEvent
{
"data": {
"agent_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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 |
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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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_id": 0,
"device_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» device_id | integer(int32) | true | The id of the device |
» 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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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_id": 0,
"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_id | integer(int32) | false | The id of the agent |
» 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 |
DomotzEyesUsageInformation
{
"limit": 0,
"usage": {
"snmp": 0,
"tcp": 0,
"total": 0
}
}
Information about Domotz Eyes current usage and limits
Properties
Name | Type | Required | Description |
---|---|---|---|
limit | integer(int32) | false | Number of allowed Domotz Eyes for the agent |
usage | object | false | none |
» snmp | integer(int32) | false | Number of configured Domotz Eyes of type snmp on the agent. |
» tcp | integer(int32) | false | Number of configured Domotz Eyes of type tcp on the agent. |
» total | integer(int32) | false | Number of configured Domotz Eyes on the agent. |
DummyDevice
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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 |
ExternalIpDevice
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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",
"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 |
IpDevice
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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",
"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 |
» status | string | false | none |
» vendor | string | false | none |
Enumerated Values
Property | Value |
---|---|
status | ONLINE |
status | OFFLINE |
status | DOWN |
status | HIDDEN |
LocalIpDevice
{
"authentication_status": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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",
"status": "ONLINE",
"vendor": "string",
"hw_address": "string",
"is_jammed": true,
"names": {
"bonjour": "string",
"dhcp": "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 | 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 |
»» snmp | string | false | none |
»» upnp | string | false | none |
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 |
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 |
encryption_protocol | DES |
encryption_protocol | AES |
version | V2 |
version | V1 |
version | V3_AUTH_PRIV |
version | V3_NO_AUTH |
version | V3_AUTH_NO_PRIV |
SNMPDomotzEye
{
"category": "OTHER",
"id": 0,
"last_update": "2019-08-24T14:15:22Z",
"latest_value": "string",
"name": "string",
"oid": "string",
"value_type": "STRING"
}
Information about a configured SNMP Domotz Eye
Properties
Name | Type | Required | Description |
---|---|---|---|
category | string | true | The category of the OID |
id | integer(int32) | true | The unique identifier of the SNMP Domotz Eye |
last_update | string(date-time) | true | The timestamp of the latest update |
latest_value | string | true | The value retrieved on the OID |
name | string | true | The name of the Domotz Eyes |
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 |
SNMPDomotzEyeCreation
{
"category": "OTHER",
"name": "string",
"oid": "string",
"value_type": "STRING"
}
SNMP Domotz Eye Data
Properties
Name | Type | Required | Description |
---|---|---|---|
category | string | true | The category of the OID |
name | string | true | The name of the Domotz Eyes |
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 |
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 |
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 |
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": "AUTHENTICATED",
"details": {
"room": "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,
"protocol": "IP",
"type": {
"detected_id": 0,
"id": 0
},
"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",
"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
{
"id": 0,
"last_update": "2019-08-24T14:15:22Z",
"port": 0,
"status": "UP"
}
Information about a configured TCP Domotz Eye
Properties
Name | Type | Required | Description |
---|---|---|---|
id | integer(int32) | true | The unique identifier of the TCP Domotz Eye |
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 Eye 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 |