NAV Navigation
Curl Go Node.JS Python
built on 27.4.2020 12:8

Introduction

Application developers can access Dome9 functionality from within applications using the Dome9 API. With version 2 of this API, developers can access functions using RESTful HTTP requests.

The resources and methods listed in this API cover the Dome9 functionality that developer applications need to onboard and manage their cloud accounts in Dome9.

The resources are grouped into Dome9 entities and Cloud Inventory entities.

Dome9 entities include functional features such as Clarity, Compliance, Dome9 Alerts, and entities such as access leases, Compliance bundles and rules, and Dome9 users and roles.

Cloud inventory includes entities such as Security Groups, instances, regions, and VPCs.

The API is based on HTTP requests and responses, and uses JSON blocks.

The base URL for the Dome9 API is https://api.dome9.com/v2/

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Authentication

The Dome9 REST API uses HTTP Basic Authentication.

You will need a V2 API key and a secret in order to use the API.

You can generate the key and secret in the Dome9 web application (https://secure.dome9.com), under 'My Settings' section.

For detailed instructions see Create a Dome9 API Key

Your permissions when using the REST API with the key will be the same as the permissions of the Dome9 user who generated the key from the Dome9 web application.

Example:

curl -u your-api-key-id:your-api-key-secret https://api.dome9.com/v2/CloudAccounts

AccessLease

The AccessLease resource has methods to create dynamic access leases, with which users can access resources in AWS accounts managed by Dome9.

Leases are for specific users (not necessarily Dome9 users) and for specific periods of time.

Once a lease has been created, it can be sent to the user for whom it was created using the AccessLeaseInvitation resource.

AccessLeaseInvitation

See also

Dynamic Access Leasing

Acquire Aws Lease

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/accesslease/aws \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "region": "us_east_1",
  "securityGroupId": "string",
  "id": "00000000-0000-0000-0000-000000000000",
  "accountId": 0,
  "name": "string",
  "ip": "string",
  "note": "string",
  "created": "2020-05-27T12:08:18Z",
  "user": "string",
  "length": "string",
  "protocol": "ALL",
  "portFrom": 0,
  "portTo": 0,
  "srl": "string"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/accesslease/aws',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/accesslease/aws', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/accesslease/aws

Create a new Access Lease for an AWS service

Body parameter

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "region": "us_east_1",
  "securityGroupId": "string",
  "id": "00000000-0000-0000-0000-000000000000",
  "accountId": 0,
  "name": "string",
  "ip": "string",
  "note": "string",
  "created": "2020-05-27T12:08:18Z",
  "user": "string",
  "length": "string",
  "protocol": "ALL",
  "portFrom": 0,
  "portTo": 0,
  "srl": "string"
}

Parameters

Parameter In Type Required Description
body body AwsAccessLeasePost true details for the lease

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AccessLease \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccessLease',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AccessLease', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AccessLease

Get a list of all active Access Leases

Example responses

200 Response

{
  "aws": [
    {
      "cloudAccountId": "00000000-0000-0000-0000-000000000000",
      "region": "us_east_1",
      "securityGroupId": 0,
      "id": "00000000-0000-0000-0000-000000000000",
      "accountId": 0,
      "name": "string",
      "ip": "string",
      "note": "string",
      "created": "2020-05-27T12:08:18Z",
      "user": "string",
      "length": "string",
      "protocol": "ALL",
      "portFrom": 0,
      "portTo": 0,
      "srl": "string"
    }
  ],
  "agents": [
    {
      "agentId": 0,
      "id": "00000000-0000-0000-0000-000000000000",
      "accountId": 0,
      "name": "string",
      "ip": "string",
      "note": "string",
      "created": "2020-05-27T12:08:18Z",
      "user": "string",
      "length": "string",
      "protocol": "ALL",
      "portFrom": 0,
      "portTo": 0,
      "srl": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK AccessLeasesGrouped

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AccessLease/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AccessLease/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AccessLease/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AccessLease/{id}

Terminate an Access Lease

Parameters

Parameter In Type Required Description
id path string(uuid) true the id of the lease to terminate

Responses

Status Meaning Description Schema
204 No Content No Content None

AccessLeaseInvitation

The AcessLeaseInvitation resource has methods to create and view invitations to users to access managed AWS account resources (such as instances) using access leases.

Invitations are sent as emails. The recipient is the user of the lease. Typically they will use the lease from the location (host) on which the email is opened. The lease is time limited, and specific to a user.

Create access leases using the AccessLease resource.

AccessLease

See also

Dynamic Access Leasing

Access Invitation

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/access-lease-invitation/access/{invitationId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/access-lease-invitation/access/{invitationId}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/access-lease-invitation/access/{invitationId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/access-lease-invitation/access/{invitationId}

Get a specific invitation

Parameters

Parameter In Type Required Description
invitationId path string(uuid) true the id of the invitation

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get Pending Invitations

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AccessLeaseInvitation \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccessLeaseInvitation',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AccessLeaseInvitation', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AccessLeaseInvitation

Get a list of pending invitations (invitations not yet activated)

These are invitations that have not yet been activated

Example responses

200 Response

[
  {
    "notifyEmail": "MyName@gmail.com",
    "length": "string",
    "recipientName": "string",
    "targetSrl": "string",
    "body": "string",
    "id": "00000000-0000-0000-0000-000000000000",
    "expirationTime": "2020-05-27T12:08:18Z",
    "pivotEntity": "string",
    "serviceName": "string",
    "issuerName": "string",
    "created": "2020-05-27T12:08:18Z"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AccessLeaseInvitation] none

Create Invitation

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AccessLeaseInvitation \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "notifyEmail": "MyName@gmail.com",
  "length": "string",
  "recipientName": "string",
  "targetSrl": "string",
  "body": "string",
  "id": "00000000-0000-0000-0000-000000000000",
  "expirationTime": "2020-05-27T12:08:18Z",
  "pivotEntity": "string",
  "serviceName": "string",
  "issuerName": "string",
  "created": "2020-05-27T12:08:18Z"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccessLeaseInvitation',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AccessLeaseInvitation', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AccessLeaseInvitation

Create a new Lease Invitation

Body parameter

{
  "notifyEmail": "MyName@gmail.com",
  "length": "string",
  "recipientName": "string",
  "targetSrl": "string",
  "body": "string",
  "id": "00000000-0000-0000-0000-000000000000",
  "expirationTime": "2020-05-27T12:08:18Z",
  "pivotEntity": "string",
  "serviceName": "string",
  "issuerName": "string",
  "created": "2020-05-27T12:08:18Z"
}

Parameters

Parameter In Type Required Description
body body AccessLeaseInvitation true lease invitation details

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AccessLeaseInvitation/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AccessLeaseInvitation/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AccessLeaseInvitation/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AccessLeaseInvitation/{id}

Delete a lease invitation

Parameters

Parameter In Type Required Description
id path string(uuid) true the id of the lease to delete

Responses

Status Meaning Description Schema
204 No Content No Content None

AccountTrust

The AccountTrust resource has methods to define a trust relationship between Dome9 accounts. This allows users in a one account to make changes and perform operations in another account.

Actions in the trustee account are performed using a role which is defined for it. The user from the trusted account assumes this role when signing in to the trustee account.

Roles

See also

Dome9 Managed Service Providers

Get Assumable Roles

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AccountTrust/assumable-roles \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccountTrust/assumable-roles',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AccountTrust/assumable-roles', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AccountTrust/assumable-roles

Get a list of objects that represent a trusted account and its assumebale roles

Example responses

200 Response

[
  {
    "accountName": "string",
    "accountId": 0,
    "roles": [
      "string"
    ]
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AccountTrustAssumableRoles] none

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AccountTrust?trustDirection=MyAccountIsTarget \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccountTrust?trustDirection=MyAccountIsTarget',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AccountTrust', params={
  'trustDirection': 'MyAccountIsTarget'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AccountTrust

Get a list of accounts which are trusted by or trust this account according to the given "trustDirection"

Parameters

Parameter In Type Required Description
trustDirection query string true Determines whether the accounts result list are the trusted/trustee accounts

Enumerated Values

Parameter Value
trustDirection MyAccountIsTarget
trustDirection MyAccountIsSource

Example responses

200 Response

[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "targetAccountName": "string",
    "sourceAccountName": "string",
    "sourceAccountId": "00000000-0000-0000-0000-000000000000",
    "description": "string",
    "restrictions": {
      "roles": [
        "string"
      ]
    }
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AccountTrust] none

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AccountTrust \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "sourceAccountId": "00000000-0000-0000-0000-000000000000",
  "description": "string",
  "restrictions": {
    "roles": [
      "string"
    ]
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccountTrust',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AccountTrust', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AccountTrust

Create a new account trust where this account is the target based on the given "SourceAccountId", i.e. this account trusts the source account

Body parameter

{
  "sourceAccountId": "00000000-0000-0000-0000-000000000000",
  "description": "string",
  "restrictions": {
    "roles": [
      "string"
    ]
  }
}

Parameters

Parameter In Type Required Description
body body AccountTrustPost true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Put

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AccountTrust/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "description": "string",
  "restrictions": {
    "roles": [
      "string"
    ]
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AccountTrust/{id}',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AccountTrust/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AccountTrust/{id}

Update the account trust description or restrictions

Body parameter

{
  "description": "string",
  "restrictions": {
    "roles": [
      "string"
    ]
  }
}

Parameters

Parameter In Type Required Description
id path string(uuid) true Account trust id
body body AccountTrustPut true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AccountTrust/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AccountTrust/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AccountTrust/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AccountTrust/{id}

Delete an account trust

Parameters

Parameter In Type Required Description
id path string(uuid) true The trust id

Responses

Status Meaning Description Schema
204 No Content No Content None

Assessment

The Assessment resource has methods to run compliance assessments on cloud accounts, and view the results.

An assessment runs a bundle, which consists of a collection of rules (or tests) that test the properties and capabilities of your cloud account and its entities.

The methods in this resource are synchronous; the response will be sent when the assessment is complete, and will include the results. The respose is typically sent within a few seconds, but for some assessments (on environments with a large number of entities, or bundles with a large number of tests), this could take several minutes.

Assessments can also be run on AWS CloudFormation Template (CFT) files.

You can get a list of all the available bundles for your account using the CompliancePolicy resource.

See results of previous assessments using the AssessmentHistoryV2 resource.

The response contains the results of the assessment.

AssessmentHistory

CompliancePolicy

See also

Compliance & Governance

Create a bundle and run an assessment with it

Run Bundle

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/assessment/bundleV2 \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "id": 0,
  "name": "string",
  "description": "string",
  "cft": {
    "rootName": "string",
    "params": [
      {
        "key": "string",
        "value": "string"
      }
    ],
    "files": [
      {
        "name": "string",
        "template": "string"
      }
    ]
  },
  "isCft": true,
  "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalCloudAccountId": "string",
  "cloudAccountId": "string",
  "region": "string",
  "cloudNetwork": "string",
  "cloudAccountType": "Aws",
  "requestId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/assessment/bundleV2',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/assessment/bundleV2', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/assessment/bundleV2

Run an assessment on a cloud environment using a bundle (V2)

Body parameter

{
  "id": 0,
  "name": "string",
  "description": "string",
  "cft": {
    "rootName": "string",
    "params": [
      {
        "key": "string",
        "value": "string"
      }
    ],
    "files": [
      {
        "name": "string",
        "template": "string"
      }
    ]
  },
  "isCft": true,
  "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalCloudAccountId": "string",
  "cloudAccountId": "string",
  "region": "string",
  "cloudNetwork": "string",
  "cloudAccountType": "Aws",
  "requestId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body AssessmentBundleRequest true The assessment request block

Example responses

200 Response

{
  "request": {
    "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
    "externalCloudAccountId": "string",
    "cloudAccountId": "string",
    "region": "string",
    "cloudNetwork": "string",
    "cloudAccountType": "Aws",
    "requestId": "00000000-0000-0000-0000-000000000000"
  },
  "tests": [
    {
      "error": "string",
      "testedCount": 0,
      "relevantCount": 0,
      "nonComplyingCount": 0,
      "exclusionStats": {
        "testedCount": 0,
        "relevantCount": 0,
        "nonComplyingCount": 0
      },
      "entityResults": [
        {
          "validationStatus": "Relevant",
          "isRelevant": true,
          "isValid": true,
          "isExcluded": true,
          "exclusionId": "00000000-0000-0000-0000-000000000000",
          "remediationId": "00000000-0000-0000-0000-000000000000",
          "error": "string",
          "testObj": {}
        }
      ],
      "rule": {
        "name": "string",
        "severity": "Informational",
        "logic": "string",
        "description": "string",
        "remediation": "string",
        "complianceTag": "string",
        "domain": "string",
        "priority": "string",
        "controlTitle": "string",
        "ruleId": "string",
        "logicHash": "string",
        "isDefault": true
      },
      "testPassed": true
    }
  ],
  "locationMetadata": {
    "account": {
      "srl": "string",
      "name": "string",
      "id": "string",
      "externalId": "string"
    },
    "region": {
      "srl": "string",
      "name": "string",
      "id": "string",
      "externalId": "string"
    },
    "cloudNetwork": {
      "srl": "string",
      "name": "string",
      "id": "string",
      "externalId": "string"
    }
  },
  "testEntities": {
    "notSupported": [
      {}
    ],
    "instance": [
      {}
    ],
    "securityGroup": [
      {}
    ],
    "elb": [
      {}
    ],
    "rds": [
      {}
    ],
    "lambda": [
      {}
    ],
    "region": [
      {}
    ],
    "virtualMachine": [
      {}
    ],
    "networkSecurityGroup": [
      {}
    ],
    "cloudTrail": [
      {}
    ],
    "nacl": [
      {}
    ],
    "vpc": [
      {}
    ],
    "subnet": [
      {}
    ],
    "s3Bucket": [
      {}
    ],
    "applicationLoadBalancer": [
      {}
    ],
    "iamUser": [
      {}
    ],
    "iamRole": [
      {}
    ],
    "iam": [
      {}
    ],
    "redshift": [
      {}
    ],
    "kms": [
      {}
    ],
    "default": [
      {}
    ],
    "vmInstance": [
      {}
    ],
    "iamGroup": [
      {}
    ],
    "efs": [
      {}
    ],
    "network": [
      {}
    ],
    "elastiCache": [
      {}
    ],
    "loadBalancer": [
      {}
    ],
    "vNet": [
      {}
    ],
    "sqldb": [
      {}
    ],
    "redisCache": [
      {}
    ],
    "applicationGateway": [
      {}
    ],
    "resourceGroup": [
      {}
    ],
    "sqlServer": [
      {}
    ],
    "ecsCluster": [
      {}
    ],
    "keyVault": [
      {}
    ],
    "networkLoadBalancer": [
      {}
    ],
    "networkInterface": [
      {}
    ],
    "ecsTaskDefinition": [
      {}
    ],
    "iamPolicy": [
      {}
    ],
    "volume": [
      {}
    ],
    "cloudFront": [
      {}
    ],
    "kinesis": [
      {}
    ],
    "iamServerCertificate": [
      {}
    ],
    "route53HostedZone": [
      {}
    ],
    "route53RecordSetGroup": [
      {}
    ],
    "acmCertificate": [
      {}
    ],
    "route53Domain": [
      {}
    ],
    "storageAccount": [
      {}
    ],
    "dynamoDbTable": [
      {}
    ],
    "ami": [
      {}
    ],
    "vpnGateway": [
      {}
    ],
    "virtualMfaDevices": [
      {}
    ],
    "internetGateway": [
      {}
    ],
    "wafRegional": [
      {}
    ],
    "lock": [
      {}
    ],
    "vpnConnection": [
      {}
    ],
    "ecsTask": [
      {}
    ],
    "customerGateway": [
      {}
    ],
    "gcpSecurityGroup": [
      {}
    ],
    "elasticIP": [
      {}
    ],
    "iamInstanceProfile": [
      {}
    ],
    "storageBucket": [
      {}
    ],
    "ecsService": [
      {}
    ],
    "project": [
      {}
    ],
    "serviceAccount": [
      {}
    ],
    "kmsKeyRing": [
      {}
    ],
    "dataWarehouse": [
      {}
    ],
    "guardDutyDetector": [
      {}
    ],
    "gcpIamPolicy": [
      {}
    ],
    "gcpIamUser": [
      {}
    ],
    "apiGateway": [
      {}
    ],
    "gcpGsuiteUser": [
      {}
    ],
    "gcpGsuiteGroup": [
      {}
    ],
    "gcpIamGroup": [
      {}
    ],
    "bigQuery": [
      {}
    ],
    "routeTable": [
      {}
    ],
    "gkeCluster": [
      {}
    ],
    "postgreSQL": [
      {}
    ],
    "vpcFlowLog": [
      {}
    ],
    "iamAccountSummary": [
      {}
    ],
    "sageMakerNotebook": [
      {}
    ],
    "containerRegistry": [
      {}
    ],
    "inspector": [
      {}
    ],
    "kmsAliases": [
      {}
    ],
    "passwordPolicy": [
      {}
    ],
    "configurationRecorder": [
      {}
    ],
    "cosmosDbAccount": [
      {}
    ],
    "networkWatcher": [
      {}
    ],
    "vpcPeeringConnection": [
      {}
    ],
    "metricAlarm": [
      {}
    ],
    "snsSubscription": [
      {}
    ],
    "logGroup": [
      {}
    ],
    "metricFilter": [
      {}
    ],
    "cloudWatchEventsRule": [
      {}
    ],
    "awsIamAccessKey": [
      {}
    ],
    "kubernetesNode": [
      {}
    ],
    "kubernetesPod": [
      {}
    ],
    "kubernetesService": [
      {}
    ],
    "logProfile": [
      {}
    ],
    "policyAssignment": [
      {}
    ],
    "kubernetesNetworkPolicy": [
      {}
    ],
    "kubernetesIngress": [
      {}
    ],
    "kubernetesPodSecurityPolicy": [
      {}
    ],
    "cloudSql": [
      {}
    ],
    "kubernetesKubelet": [
      {}
    ],
    "autoScalingGroup": [
      {}
    ],
    "elasticSearchDomain": [
      {}
    ],
    "logicEntity": [
      {}
    ],
    "vpcEndpoint": [
      {}
    ],
    "cloudFunction": [
      {}
    ],
    "logicApp": [
      {}
    ],
    "applicationSecurityGroup": [
      {}
    ],
    "awsCodeDependency": [
      {}
    ],
    "bigTable": [
      {}
    ],
    "kubernetesAccountMetadata": [
      {}
    ],
    "virtualMachineScaleSet": [
      {}
    ],
    "analysisServiceServer": [
      {}
    ],
    "emrCluster": [
      {}
    ],
    "aksCluster": [
      {}
    ],
    "pubSubTopic": [
      {}
    ],
    "pubSubSubscription": [
      {}
    ],
    "kubernetesImage": [
      {}
    ],
    "policyDefinition": [
      {}
    ],
    "eksCluster": [
      {}
    ],
    "sqs": [
      {}
    ],
    "kubernetesServiceAccount": [
      {}
    ],
    "kubernetesRole": [
      {}
    ],
    "kubernetesClusterRole": [
      {}
    ],
    "kubernetesRoleBinding": [
      {}
    ],
    "kubernetesClusterRoleBinding": [
      {}
    ],
    "snsTopic": [
      {}
    ],
    "webApp": [
      {}
    ],
    "functionApp": [
      {}
    ],
    "kubernetesCluster": [
      {}
    ],
    "kubernetesNamespace": [
      {}
    ],
    "organization": [
      {}
    ],
    "account": [
      {}
    ],
    "organizationUnit": [
      {}
    ],
    "user": [
      {}
    ],
    "userCredential": [
      {}
    ],
    "configSetting": [
      {}
    ]
  },
  "dataSyncStatus": [
    {
      "entityType": "NotSupported",
      "recentlySuccessfulSync": true,
      "generalFetchPermissionIssues": true,
      "entitiesWithPermissionIssues": [
        {
          "externalId": "string",
          "name": "string",
          "cloudVendorIdentifier": "string"
        }
      ]
    }
  ],
  "assessmentPassed": true,
  "hasErrors": true,
  "id": 0
}

Responses

Status Meaning Description Schema
200 OK OK AssessmentResult

AssessmentHistoryV2

The AssessmentHistoryV2 resource has methods to retrieve lists of previous compliance assessments, and specific assessment results. The assessments returned are for the Dome9 account of the user making the request, and can cover all cloud accounts for that user.

Assessments histories can be retrieved for a specified period of time (from, to), and can be filtered by assessment name. Each result has an id, which is used to then retrieve the specific assessment results.

Assessment

CompliancePolicy

Get Bundle Results

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/bundleResults?bundleId=0&cloudAccountIds=string&fromTime=2020-05-27T12%3A08%3A18Z \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/bundleResults?bundleId=0&cloudAccountIds=string&fromTime=2020-05-27T12%3A08%3A18Z',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/bundleResults', params={
  'bundleId': '0',  'cloudAccountIds': 'string',  'fromTime': '2020-05-27T12:08:18Z'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/bundleResults

Get most recent assessment results for a specific bundle, for a list of cloud accounts

Parameters

Parameter In Type Required Description
bundleId query integer(int64) true the bundle used for the assessment (for all the accounts in the list)
cloudAccountIds query string true comma separated list of cloud accounts
fromTime query string(date-time) true the time the assessment was done
epsilonInMinutes query integer(int64) false period of time (in min) back from the fromTime to look for results; only results in this range will be returned
requestId query string(uuid) false an optional request id; the same value will appear in the response

Example responses

200 Response

[
  {
    "triggeredBy": "Unknown",
    "tests": [
      {
        "error": "string",
        "testedCount": 0,
        "relevantCount": 0,
        "nonComplyingCount": 0,
        "exclusionStats": {
          "testedCount": 0,
          "relevantCount": 0,
          "nonComplyingCount": 0
        },
        "entityResults": [
          {
            "validationStatus": "Relevant",
            "isRelevant": true,
            "isValid": true,
            "isExcluded": true,
            "exclusionId": "00000000-0000-0000-0000-000000000000",
            "remediationId": "00000000-0000-0000-0000-000000000000",
            "error": "string",
            "testObj": {}
          }
        ],
        "rule": {
          "name": "string",
          "severity": "Informational",
          "logic": "string",
          "description": "string",
          "remediation": "string",
          "complianceTag": "string",
          "domain": "string",
          "priority": "string",
          "controlTitle": "string",
          "ruleId": "string",
          "logicHash": "string",
          "isDefault": true
        },
        "testPassed": true
      }
    ],
    "testEntities": {
      "notSupported": [
        {}
      ],
      "instance": [
        {}
      ],
      "securityGroup": [
        {}
      ],
      "elb": [
        {}
      ],
      "rds": [
        {}
      ],
      "lambda": [
        {}
      ],
      "region": [
        {}
      ],
      "virtualMachine": [
        {}
      ],
      "networkSecurityGroup": [
        {}
      ],
      "cloudTrail": [
        {}
      ],
      "nacl": [
        {}
      ],
      "vpc": [
        {}
      ],
      "subnet": [
        {}
      ],
      "s3Bucket": [
        {}
      ],
      "applicationLoadBalancer": [
        {}
      ],
      "iamUser": [
        {}
      ],
      "iamRole": [
        {}
      ],
      "iam": [
        {}
      ],
      "redshift": [
        {}
      ],
      "kms": [
        {}
      ],
      "default": [
        {}
      ],
      "vmInstance": [
        {}
      ],
      "iamGroup": [
        {}
      ],
      "efs": [
        {}
      ],
      "network": [
        {}
      ],
      "elastiCache": [
        {}
      ],
      "loadBalancer": [
        {}
      ],
      "vNet": [
        {}
      ],
      "sqldb": [
        {}
      ],
      "redisCache": [
        {}
      ],
      "applicationGateway": [
        {}
      ],
      "resourceGroup": [
        {}
      ],
      "sqlServer": [
        {}
      ],
      "ecsCluster": [
        {}
      ],
      "keyVault": [
        {}
      ],
      "networkLoadBalancer": [
        {}
      ],
      "networkInterface": [
        {}
      ],
      "ecsTaskDefinition": [
        {}
      ],
      "iamPolicy": [
        {}
      ],
      "volume": [
        {}
      ],
      "cloudFront": [
        {}
      ],
      "kinesis": [
        {}
      ],
      "iamServerCertificate": [
        {}
      ],
      "route53HostedZone": [
        {}
      ],
      "route53RecordSetGroup": [
        {}
      ],
      "acmCertificate": [
        {}
      ],
      "route53Domain": [
        {}
      ],
      "storageAccount": [
        {}
      ],
      "dynamoDbTable": [
        {}
      ],
      "ami": [
        {}
      ],
      "vpnGateway": [
        {}
      ],
      "virtualMfaDevices": [
        {}
      ],
      "internetGateway": [
        {}
      ],
      "wafRegional": [
        {}
      ],
      "lock": [
        {}
      ],
      "vpnConnection": [
        {}
      ],
      "ecsTask": [
        {}
      ],
      "customerGateway": [
        {}
      ],
      "gcpSecurityGroup": [
        {}
      ],
      "elasticIP": [
        {}
      ],
      "iamInstanceProfile": [
        {}
      ],
      "storageBucket": [
        {}
      ],
      "ecsService": [
        {}
      ],
      "project": [
        {}
      ],
      "serviceAccount": [
        {}
      ],
      "kmsKeyRing": [
        {}
      ],
      "dataWarehouse": [
        {}
      ],
      "guardDutyDetector": [
        {}
      ],
      "gcpIamPolicy": [
        {}
      ],
      "gcpIamUser": [
        {}
      ],
      "apiGateway": [
        {}
      ],
      "gcpGsuiteUser": [
        {}
      ],
      "gcpGsuiteGroup": [
        {}
      ],
      "gcpIamGroup": [
        {}
      ],
      "bigQuery": [
        {}
      ],
      "routeTable": [
        {}
      ],
      "gkeCluster": [
        {}
      ],
      "postgreSQL": [
        {}
      ],
      "vpcFlowLog": [
        {}
      ],
      "iamAccountSummary": [
        {}
      ],
      "sageMakerNotebook": [
        {}
      ],
      "containerRegistry": [
        {}
      ],
      "inspector": [
        {}
      ],
      "kmsAliases": [
        {}
      ],
      "passwordPolicy": [
        {}
      ],
      "configurationRecorder": [
        {}
      ],
      "cosmosDbAccount": [
        {}
      ],
      "networkWatcher": [
        {}
      ],
      "vpcPeeringConnection": [
        {}
      ],
      "metricAlarm": [
        {}
      ],
      "snsSubscription": [
        {}
      ],
      "logGroup": [
        {}
      ],
      "metricFilter": [
        {}
      ],
      "cloudWatchEventsRule": [
        {}
      ],
      "awsIamAccessKey": [
        {}
      ],
      "kubernetesNode": [
        {}
      ],
      "kubernetesPod": [
        {}
      ],
      "kubernetesService": [
        {}
      ],
      "logProfile": [
        {}
      ],
      "policyAssignment": [
        {}
      ],
      "kubernetesNetworkPolicy": [
        {}
      ],
      "kubernetesIngress": [
        {}
      ],
      "kubernetesPodSecurityPolicy": [
        {}
      ],
      "cloudSql": [
        {}
      ],
      "kubernetesKubelet": [
        {}
      ],
      "autoScalingGroup": [
        {}
      ],
      "elasticSearchDomain": [
        {}
      ],
      "logicEntity": [
        {}
      ],
      "vpcEndpoint": [
        {}
      ],
      "cloudFunction": [
        {}
      ],
      "logicApp": [
        {}
      ],
      "applicationSecurityGroup": [
        {}
      ],
      "awsCodeDependency": [
        {}
      ],
      "bigTable": [
        {}
      ],
      "kubernetesAccountMetadata": [
        {}
      ],
      "virtualMachineScaleSet": [
        {}
      ],
      "analysisServiceServer": [
        {}
      ],
      "emrCluster": [
        {}
      ],
      "aksCluster": [
        {}
      ],
      "pubSubTopic": [
        {}
      ],
      "pubSubSubscription": [
        {}
      ],
      "kubernetesImage": [
        {}
      ],
      "policyDefinition": [
        {}
      ],
      "eksCluster": [
        {}
      ],
      "sqs": [
        {}
      ],
      "kubernetesServiceAccount": [
        {}
      ],
      "kubernetesRole": [
        {}
      ],
      "kubernetesClusterRole": [
        {}
      ],
      "kubernetesRoleBinding": [
        {}
      ],
      "kubernetesClusterRoleBinding": [
        {}
      ],
      "snsTopic": [
        {}
      ],
      "webApp": [
        {}
      ],
      "functionApp": [
        {}
      ],
      "kubernetesCluster": [
        {}
      ],
      "kubernetesNamespace": [
        {}
      ],
      "organization": [
        {}
      ],
      "account": [
        {}
      ],
      "organizationUnit": [
        {}
      ],
      "user": [
        {}
      ],
      "userCredential": [
        {}
      ],
      "configSetting": [
        {}
      ]
    },
    "exclusions": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "ruleLogicHash": "string",
        "ruleName": "string",
        "ruleId": "string",
        "logic": "string",
        "bundleId": 0,
        "cloudAccountId": "00000000-0000-0000-0000-000000000000",
        "cloudAccountType": "Aws",
        "comment": "string"
      }
    ],
    "remediations": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "ruleLogicHash": "string",
        "ruleName": "string",
        "ruleId": "string",
        "logic": "string",
        "rulesetId": 0,
        "cloudAccountId": "00000000-0000-0000-0000-000000000000",
        "platform": "Aws",
        "comment": "string",
        "cloudBots": [
          "string"
        ]
      }
    ],
    "dataSyncStatus": [
      {
        "entityType": "NotSupported",
        "recentlySuccessfulSync": true,
        "generalFetchPermissionIssues": true,
        "entitiesWithPermissionIssues": [
          {
            "externalId": "string",
            "name": "string",
            "cloudVendorIdentifier": "string"
          }
        ]
      }
    ],
    "createdTime": "2020-05-27T12:08:18Z",
    "id": 0,
    "assessmentPassed": true,
    "hasErrors": true,
    "stats": {
      "passed": 0,
      "failed": 0,
      "error": 0,
      "failedTests": 0,
      "logicallyTested": 0,
      "failedEntities": 0,
      "excludedTests": 0,
      "excludedFailedTests": 0,
      "excludedRules": 0
    },
    "request": {
      "isTemplate": true,
      "id": 0,
      "name": "string",
      "description": "string",
      "cft": {
        "rootName": "string",
        "params": [
          {
            "key": "string",
            "value": "string"
          }
        ],
        "files": [
          {
            "name": "string",
            "template": "string"
          }
        ]
      },
      "isCft": true,
      "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
      "externalCloudAccountId": "string",
      "cloudAccountId": "string",
      "region": "string",
      "cloudNetwork": "string",
      "cloudAccountType": "Aws",
      "requestId": "00000000-0000-0000-0000-000000000000"
    },
    "hasDataSyncStatusIssues": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AssessmentHistoryResultV2] none

Enumerated Values

Property Value
triggeredBy Unknown
triggeredBy ContinuousCompliancePolicy
triggeredBy Manual
triggeredBy SystemBundle
triggeredBy Serverless
validationStatus Relevant
validationStatus Valid
validationStatus Excluded
severity Informational
severity Low
severity Medium
severity High
severity Critical
cloudAccountType Aws
cloudAccountType Azure
cloudAccountType Google
cloudAccountType Kubernetes
platform Aws
platform Azure
platform Google
platform Kubernetes
entityType NotSupported
entityType Instance
entityType SecurityGroup
entityType ELB
entityType RDS
entityType Lambda
entityType Region
entityType VirtualMachine
entityType NetworkSecurityGroup
entityType CloudTrail
entityType NACL
entityType VPC
entityType Subnet
entityType S3Bucket
entityType ApplicationLoadBalancer
entityType IamUser
entityType IamRole
entityType Iam
entityType Redshift
entityType KMS
entityType Default
entityType VMInstance
entityType IamGroup
entityType EFS
entityType Network
entityType ElastiCache
entityType LoadBalancer
entityType VNet
entityType SQLDB
entityType RedisCache
entityType ApplicationGateway
entityType ResourceGroup
entityType SQLServer
entityType EcsCluster
entityType KeyVault
entityType NetworkLoadBalancer
entityType NetworkInterface
entityType EcsTaskDefinition
entityType IamPolicy
entityType Volume
entityType CloudFront
entityType Kinesis
entityType IamServerCertificate
entityType Route53HostedZone
entityType Route53RecordSetGroup
entityType AcmCertificate
entityType Route53Domain
entityType StorageAccount
entityType DynamoDbTable
entityType AMI
entityType VPNGateway
entityType VirtualMfaDevices
entityType InternetGateway
entityType WAFRegional
entityType Lock
entityType VPNConnection
entityType EcsTask
entityType CustomerGateway
entityType GcpSecurityGroup
entityType ElasticIP
entityType IamInstanceProfile
entityType StorageBucket
entityType EcsService
entityType Project
entityType ServiceAccount
entityType KmsKeyRing
entityType DataWarehouse
entityType GuardDutyDetector
entityType GcpIamPolicy
entityType GcpIamUser
entityType ApiGateway
entityType GcpGsuiteUser
entityType GcpGsuiteGroup
entityType GcpIamGroup
entityType BigQuery
entityType RouteTable
entityType GkeCluster
entityType PostgreSQL
entityType VpcFlowLog
entityType IamAccountSummary
entityType SageMakerNotebook
entityType ContainerRegistry
entityType Inspector
entityType KmsAliases
entityType PasswordPolicy
entityType ConfigurationRecorder
entityType CosmosDbAccount
entityType NetworkWatcher
entityType VpcPeeringConnection
entityType MetricAlarm
entityType SnsSubscription
entityType LogGroup
entityType MetricFilter
entityType CloudWatchEventsRule
entityType AwsIamAccessKey
entityType KubernetesNode
entityType KubernetesPod
entityType KubernetesService
entityType LogProfile
entityType PolicyAssignment
entityType KubernetesNetworkPolicy
entityType KubernetesIngress
entityType KubernetesPodSecurityPolicy
entityType CloudSql
entityType KubernetesKubelet
entityType AutoScalingGroup
entityType ElasticSearchDomain
entityType LogicEntity
entityType VpcEndpoint
entityType CloudFunction
entityType LogicApp
entityType ApplicationSecurityGroup
entityType AwsCodeDependency
entityType BigTable
entityType KubernetesAccountMetadata
entityType VirtualMachineScaleSet
entityType AnalysisServiceServer
entityType EmrCluster
entityType AksCluster
entityType PubSubTopic
entityType PubSubSubscription
entityType KubernetesImage
entityType PolicyDefinition
entityType EksCluster
entityType Sqs
entityType KubernetesServiceAccount
entityType KubernetesRole
entityType KubernetesClusterRole
entityType KubernetesRoleBinding
entityType KubernetesClusterRoleBinding
entityType SnsTopic
entityType WebApp
entityType FunctionApp
entityType KubernetesCluster
entityType KubernetesNamespace
entityType Organization
entityType Account
entityType OrganizationUnit
entityType User
entityType UserCredential
entityType ConfigSetting
cloudAccountType Aws
cloudAccountType Azure
cloudAccountType Google
cloudAccountType Kubernetes

Get Assessment Trend

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrend?bundleId=0&cloudAccountId=string&from=2020-05-27T12%3A08%3A18Z&to=2020-05-27T12%3A08%3A18Z \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrend?bundleId=0&cloudAccountId=string&from=2020-05-27T12%3A08%3A18Z&to=2020-05-27T12%3A08%3A18Z',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrend', params={
  'bundleId': '0',  'cloudAccountId': 'string',  'from': '2020-05-27T12:08:18Z',  'to': '2020-05-27T12:08:18Z'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/assessmentTrend

Get the assessment trend for the selected time range (maximum of 93 days)

Parameters

Parameter In Type Required Description
bundleId query integer(int64) true Bundle ID
cloudAccountId query string(uuid) true Cloud Account ID
from query string(date-time) true From Date
to query string(date-time) true To Date

Example responses

200 Response

[
  {
    "assessmentId": 0,
    "assessmentDate": "2020-05-27T12:08:18Z",
    "failedTests": 0,
    "totalTests": 0,
    "passedTests": 0
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AssessmentTrendItem] none

Get Assessment Trend Organizational Unit

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrendOrganizationalUnit?rulesetId=0&organizationalUnitId=string&from=2020-05-27T12%3A08%3A18Z&to=2020-05-27T12%3A08%3A18Z \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrendOrganizationalUnit?rulesetId=0&organizationalUnitId=string&from=2020-05-27T12%3A08%3A18Z&to=2020-05-27T12%3A08%3A18Z',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/assessmentTrendOrganizationalUnit', params={
  'rulesetId': '0',  'organizationalUnitId': 'string',  'from': '2020-05-27T12:08:18Z',  'to': '2020-05-27T12:08:18Z'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/assessmentTrendOrganizationalUnit

Get the assessment trend for the selected time range (maximum of 93 days)

Parameters

Parameter In Type Required Description
rulesetId query integer(int64) true Ruleset ID
organizationalUnitId query string(uuid) true Organizational Unit ID
from query string(date-time) true From Date
to query string(date-time) true To Date

Example responses

200 Response

[
  {
    "assessmentDate": "2020-05-27T12:08:18Z",
    "failedTests": 0,
    "totalTests": 0,
    "passedTests": 0
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [OrganizationalUnitTrendItem] none

Get Last Assessment Results View

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults/view \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountBundleFilters": [
    {
      "bundleIds": [
        0
      ],
      "cloudAccountIds": [
        "00000000-0000-0000-0000-000000000000"
      ],
      "cloudAccountType": "Aws"
    }
  ],
  "from": "2020-05-27T12:08:18Z",
  "to": "2020-05-27T12:08:18Z"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults/view',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults/view', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AssessmentHistoryV2/LastAssessmentResults/view

Get last assessment results for selected cloud accounts and bundles. Does not return details for the tests or test entities.

Body parameter

{
  "cloudAccountBundleFilters": [
    {
      "bundleIds": [
        0
      ],
      "cloudAccountIds": [
        "00000000-0000-0000-0000-000000000000"
      ],
      "cloudAccountType": "Aws"
    }
  ],
  "from": "2020-05-27T12:08:18Z",
  "to": "2020-05-27T12:08:18Z"
}

Parameters

Parameter In Type Required Description
body body AssessmentsRequestFilter true block that specifies the accounts and bundles

Example responses

200 Response

[
  {
    "createdTime": "2020-05-27T12:08:18Z",
    "id": 0,
    "triggeredBy": "Unknown",
    "assessmentPassed": true,
    "hasErrors": true,
    "stats": {
      "passed": 0,
      "failed": 0,
      "error": 0,
      "failedTests": 0,
      "logicallyTested": 0,
      "failedEntities": 0,
      "excludedTests": 0,
      "excludedFailedTests": 0,
      "excludedRules": 0
    },
    "request": {
      "isTemplate": true,
      "id": 0,
      "name": "string",
      "description": "string",
      "cft": {
        "rootName": "string",
        "params": [
          {
            "key": "string",
            "value": "string"
          }
        ],
        "files": [
          {
            "name": "string",
            "template": "string"
          }
        ]
      },
      "isCft": true,
      "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
      "externalCloudAccountId": "string",
      "cloudAccountId": "string",
      "region": "string",
      "cloudNetwork": "string",
      "cloudAccountType": "Aws",
      "requestId": "00000000-0000-0000-0000-000000000000"
    },
    "hasDataSyncStatusIssues": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AssessmentHistoryViewResultV2] none

Enumerated Values

Property Value
triggeredBy Unknown
triggeredBy ContinuousCompliancePolicy
triggeredBy Manual
triggeredBy SystemBundle
triggeredBy Serverless
cloudAccountType Aws
cloudAccountType Azure
cloudAccountType Google
cloudAccountType Kubernetes

Get Last Assessment Results

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountBundleFilters": [
    {
      "bundleIds": [
        0
      ],
      "cloudAccountIds": [
        "00000000-0000-0000-0000-000000000000"
      ],
      "cloudAccountType": "Aws"
    }
  ],
  "from": "2020-05-27T12:08:18Z",
  "to": "2020-05-27T12:08:18Z"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AssessmentHistoryV2/LastAssessmentResults', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AssessmentHistoryV2/LastAssessmentResults

Get last assessment results for selected cloud accounts and bundles. Includes details of tests and test entities.

Body parameter

{
  "cloudAccountBundleFilters": [
    {
      "bundleIds": [
        0
      ],
      "cloudAccountIds": [
        "00000000-0000-0000-0000-000000000000"
      ],
      "cloudAccountType": "Aws"
    }
  ],
  "from": "2020-05-27T12:08:18Z",
  "to": "2020-05-27T12:08:18Z"
}

Parameters

Parameter In Type Required Description
body body AssessmentsRequestFilter true block that specifies the accounts and bundles

Example responses

200 Response

[
  {
    "triggeredBy": "Unknown",
    "tests": [
      {
        "error": "string",
        "testedCount": 0,
        "relevantCount": 0,
        "nonComplyingCount": 0,
        "exclusionStats": {
          "testedCount": 0,
          "relevantCount": 0,
          "nonComplyingCount": 0
        },
        "entityResults": [
          {
            "validationStatus": "Relevant",
            "isRelevant": true,
            "isValid": true,
            "isExcluded": true,
            "exclusionId": "00000000-0000-0000-0000-000000000000",
            "remediationId": "00000000-0000-0000-0000-000000000000",
            "error": "string",
            "testObj": {}
          }
        ],
        "rule": {
          "name": "string",
          "severity": "Informational",
          "logic": "string",
          "description": "string",
          "remediation": "string",
          "complianceTag": "string",
          "domain": "string",
          "priority": "string",
          "controlTitle": "string",
          "ruleId": "string",
          "logicHash": "string",
          "isDefault": true
        },
        "testPassed": true
      }
    ],
    "testEntities": {
      "notSupported": [
        {}
      ],
      "instance": [
        {}
      ],
      "securityGroup": [
        {}
      ],
      "elb": [
        {}
      ],
      "rds": [
        {}
      ],
      "lambda": [
        {}
      ],
      "region": [
        {}
      ],
      "virtualMachine": [
        {}
      ],
      "networkSecurityGroup": [
        {}
      ],
      "cloudTrail": [
        {}
      ],
      "nacl": [
        {}
      ],
      "vpc": [
        {}
      ],
      "subnet": [
        {}
      ],
      "s3Bucket": [
        {}
      ],
      "applicationLoadBalancer": [
        {}
      ],
      "iamUser": [
        {}
      ],
      "iamRole": [
        {}
      ],
      "iam": [
        {}
      ],
      "redshift": [
        {}
      ],
      "kms": [
        {}
      ],
      "default": [
        {}
      ],
      "vmInstance": [
        {}
      ],
      "iamGroup": [
        {}
      ],
      "efs": [
        {}
      ],
      "network": [
        {}
      ],
      "elastiCache": [
        {}
      ],
      "loadBalancer": [
        {}
      ],
      "vNet": [
        {}
      ],
      "sqldb": [
        {}
      ],
      "redisCache": [
        {}
      ],
      "applicationGateway": [
        {}
      ],
      "resourceGroup": [
        {}
      ],
      "sqlServer": [
        {}
      ],
      "ecsCluster": [
        {}
      ],
      "keyVault": [
        {}
      ],
      "networkLoadBalancer": [
        {}
      ],
      "networkInterface": [
        {}
      ],
      "ecsTaskDefinition": [
        {}
      ],
      "iamPolicy": [
        {}
      ],
      "volume": [
        {}
      ],
      "cloudFront": [
        {}
      ],
      "kinesis": [
        {}
      ],
      "iamServerCertificate": [
        {}
      ],
      "route53HostedZone": [
        {}
      ],
      "route53RecordSetGroup": [
        {}
      ],
      "acmCertificate": [
        {}
      ],
      "route53Domain": [
        {}
      ],
      "storageAccount": [
        {}
      ],
      "dynamoDbTable": [
        {}
      ],
      "ami": [
        {}
      ],
      "vpnGateway": [
        {}
      ],
      "virtualMfaDevices": [
        {}
      ],
      "internetGateway": [
        {}
      ],
      "wafRegional": [
        {}
      ],
      "lock": [
        {}
      ],
      "vpnConnection": [
        {}
      ],
      "ecsTask": [
        {}
      ],
      "customerGateway": [
        {}
      ],
      "gcpSecurityGroup": [
        {}
      ],
      "elasticIP": [
        {}
      ],
      "iamInstanceProfile": [
        {}
      ],
      "storageBucket": [
        {}
      ],
      "ecsService": [
        {}
      ],
      "project": [
        {}
      ],
      "serviceAccount": [
        {}
      ],
      "kmsKeyRing": [
        {}
      ],
      "dataWarehouse": [
        {}
      ],
      "guardDutyDetector": [
        {}
      ],
      "gcpIamPolicy": [
        {}
      ],
      "gcpIamUser": [
        {}
      ],
      "apiGateway": [
        {}
      ],
      "gcpGsuiteUser": [
        {}
      ],
      "gcpGsuiteGroup": [
        {}
      ],
      "gcpIamGroup": [
        {}
      ],
      "bigQuery": [
        {}
      ],
      "routeTable": [
        {}
      ],
      "gkeCluster": [
        {}
      ],
      "postgreSQL": [
        {}
      ],
      "vpcFlowLog": [
        {}
      ],
      "iamAccountSummary": [
        {}
      ],
      "sageMakerNotebook": [
        {}
      ],
      "containerRegistry": [
        {}
      ],
      "inspector": [
        {}
      ],
      "kmsAliases": [
        {}
      ],
      "passwordPolicy": [
        {}
      ],
      "configurationRecorder": [
        {}
      ],
      "cosmosDbAccount": [
        {}
      ],
      "networkWatcher": [
        {}
      ],
      "vpcPeeringConnection": [
        {}
      ],
      "metricAlarm": [
        {}
      ],
      "snsSubscription": [
        {}
      ],
      "logGroup": [
        {}
      ],
      "metricFilter": [
        {}
      ],
      "cloudWatchEventsRule": [
        {}
      ],
      "awsIamAccessKey": [
        {}
      ],
      "kubernetesNode": [
        {}
      ],
      "kubernetesPod": [
        {}
      ],
      "kubernetesService": [
        {}
      ],
      "logProfile": [
        {}
      ],
      "policyAssignment": [
        {}
      ],
      "kubernetesNetworkPolicy": [
        {}
      ],
      "kubernetesIngress": [
        {}
      ],
      "kubernetesPodSecurityPolicy": [
        {}
      ],
      "cloudSql": [
        {}
      ],
      "kubernetesKubelet": [
        {}
      ],
      "autoScalingGroup": [
        {}
      ],
      "elasticSearchDomain": [
        {}
      ],
      "logicEntity": [
        {}
      ],
      "vpcEndpoint": [
        {}
      ],
      "cloudFunction": [
        {}
      ],
      "logicApp": [
        {}
      ],
      "applicationSecurityGroup": [
        {}
      ],
      "awsCodeDependency": [
        {}
      ],
      "bigTable": [
        {}
      ],
      "kubernetesAccountMetadata": [
        {}
      ],
      "virtualMachineScaleSet": [
        {}
      ],
      "analysisServiceServer": [
        {}
      ],
      "emrCluster": [
        {}
      ],
      "aksCluster": [
        {}
      ],
      "pubSubTopic": [
        {}
      ],
      "pubSubSubscription": [
        {}
      ],
      "kubernetesImage": [
        {}
      ],
      "policyDefinition": [
        {}
      ],
      "eksCluster": [
        {}
      ],
      "sqs": [
        {}
      ],
      "kubernetesServiceAccount": [
        {}
      ],
      "kubernetesRole": [
        {}
      ],
      "kubernetesClusterRole": [
        {}
      ],
      "kubernetesRoleBinding": [
        {}
      ],
      "kubernetesClusterRoleBinding": [
        {}
      ],
      "snsTopic": [
        {}
      ],
      "webApp": [
        {}
      ],
      "functionApp": [
        {}
      ],
      "kubernetesCluster": [
        {}
      ],
      "kubernetesNamespace": [
        {}
      ],
      "organization": [
        {}
      ],
      "account": [
        {}
      ],
      "organizationUnit": [
        {}
      ],
      "user": [
        {}
      ],
      "userCredential": [
        {}
      ],
      "configSetting": [
        {}
      ]
    },
    "exclusions": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "ruleLogicHash": "string",
        "ruleName": "string",
        "ruleId": "string",
        "logic": "string",
        "bundleId": 0,
        "cloudAccountId": "00000000-0000-0000-0000-000000000000",
        "cloudAccountType": "Aws",
        "comment": "string"
      }
    ],
    "remediations": [
      {
        "id": "00000000-0000-0000-0000-000000000000",
        "ruleLogicHash": "string",
        "ruleName": "string",
        "ruleId": "string",
        "logic": "string",
        "rulesetId": 0,
        "cloudAccountId": "00000000-0000-0000-0000-000000000000",
        "platform": "Aws",
        "comment": "string",
        "cloudBots": [
          "string"
        ]
      }
    ],
    "dataSyncStatus": [
      {
        "entityType": "NotSupported",
        "recentlySuccessfulSync": true,
        "generalFetchPermissionIssues": true,
        "entitiesWithPermissionIssues": [
          {
            "externalId": "string",
            "name": "string",
            "cloudVendorIdentifier": "string"
          }
        ]
      }
    ],
    "createdTime": "2020-05-27T12:08:18Z",
    "id": 0,
    "assessmentPassed": true,
    "hasErrors": true,
    "stats": {
      "passed": 0,
      "failed": 0,
      "error": 0,
      "failedTests": 0,
      "logicallyTested": 0,
      "failedEntities": 0,
      "excludedTests": 0,
      "excludedFailedTests": 0,
      "excludedRules": 0
    },
    "request": {
      "isTemplate": true,
      "id": 0,
      "name": "string",
      "description": "string",
      "cft": {
        "rootName": "string",
        "params": [
          {
            "key": "string",
            "value": "string"
          }
        ],
        "files": [
          {
            "name": "string",
            "template": "string"
          }
        ]
      },
      "isCft": true,
      "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
      "externalCloudAccountId": "string",
      "cloudAccountId": "string",
      "region": "string",
      "cloudNetwork": "string",
      "cloudAccountType": "Aws",
      "requestId": "00000000-0000-0000-0000-000000000000"
    },
    "hasDataSyncStatusIssues": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AssessmentHistoryResultV2] none

Enumerated Values

Property Value
triggeredBy Unknown
triggeredBy ContinuousCompliancePolicy
triggeredBy Manual
triggeredBy SystemBundle
triggeredBy Serverless
validationStatus Relevant
validationStatus Valid
validationStatus Excluded
severity Informational
severity Low
severity Medium
severity High
severity Critical
cloudAccountType Aws
cloudAccountType Azure
cloudAccountType Google
cloudAccountType Kubernetes
platform Aws
platform Azure
platform Google
platform Kubernetes
entityType NotSupported
entityType Instance
entityType SecurityGroup
entityType ELB
entityType RDS
entityType Lambda
entityType Region
entityType VirtualMachine
entityType NetworkSecurityGroup
entityType CloudTrail
entityType NACL
entityType VPC
entityType Subnet
entityType S3Bucket
entityType ApplicationLoadBalancer
entityType IamUser
entityType IamRole
entityType Iam
entityType Redshift
entityType KMS
entityType Default
entityType VMInstance
entityType IamGroup
entityType EFS
entityType Network
entityType ElastiCache
entityType LoadBalancer
entityType VNet
entityType SQLDB
entityType RedisCache
entityType ApplicationGateway
entityType ResourceGroup
entityType SQLServer
entityType EcsCluster
entityType KeyVault
entityType NetworkLoadBalancer
entityType NetworkInterface
entityType EcsTaskDefinition
entityType IamPolicy
entityType Volume
entityType CloudFront
entityType Kinesis
entityType IamServerCertificate
entityType Route53HostedZone
entityType Route53RecordSetGroup
entityType AcmCertificate
entityType Route53Domain
entityType StorageAccount
entityType DynamoDbTable
entityType AMI
entityType VPNGateway
entityType VirtualMfaDevices
entityType InternetGateway
entityType WAFRegional
entityType Lock
entityType VPNConnection
entityType EcsTask
entityType CustomerGateway
entityType GcpSecurityGroup
entityType ElasticIP
entityType IamInstanceProfile
entityType StorageBucket
entityType EcsService
entityType Project
entityType ServiceAccount
entityType KmsKeyRing
entityType DataWarehouse
entityType GuardDutyDetector
entityType GcpIamPolicy
entityType GcpIamUser
entityType ApiGateway
entityType GcpGsuiteUser
entityType GcpGsuiteGroup
entityType GcpIamGroup
entityType BigQuery
entityType RouteTable
entityType GkeCluster
entityType PostgreSQL
entityType VpcFlowLog
entityType IamAccountSummary
entityType SageMakerNotebook
entityType ContainerRegistry
entityType Inspector
entityType KmsAliases
entityType PasswordPolicy
entityType ConfigurationRecorder
entityType CosmosDbAccount
entityType NetworkWatcher
entityType VpcPeeringConnection
entityType MetricAlarm
entityType SnsSubscription
entityType LogGroup
entityType MetricFilter
entityType CloudWatchEventsRule
entityType AwsIamAccessKey
entityType KubernetesNode
entityType KubernetesPod
entityType KubernetesService
entityType LogProfile
entityType PolicyAssignment
entityType KubernetesNetworkPolicy
entityType KubernetesIngress
entityType KubernetesPodSecurityPolicy
entityType CloudSql
entityType KubernetesKubelet
entityType AutoScalingGroup
entityType ElasticSearchDomain
entityType LogicEntity
entityType VpcEndpoint
entityType CloudFunction
entityType LogicApp
entityType ApplicationSecurityGroup
entityType AwsCodeDependency
entityType BigTable
entityType KubernetesAccountMetadata
entityType VirtualMachineScaleSet
entityType AnalysisServiceServer
entityType EmrCluster
entityType AksCluster
entityType PubSubTopic
entityType PubSubSubscription
entityType KubernetesImage
entityType PolicyDefinition
entityType EksCluster
entityType Sqs
entityType KubernetesServiceAccount
entityType KubernetesRole
entityType KubernetesClusterRole
entityType KubernetesRoleBinding
entityType KubernetesClusterRoleBinding
entityType SnsTopic
entityType WebApp
entityType FunctionApp
entityType KubernetesCluster
entityType KubernetesNamespace
entityType Organization
entityType Account
entityType OrganizationUnit
entityType User
entityType UserCredential
entityType ConfigSetting
cloudAccountType Aws
cloudAccountType Azure
cloudAccountType Google
cloudAccountType Kubernetes

Get Organizational Units Last Assessment Statistics

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AssessmentHistoryV2/OrganizationalUnitsLastAssessmentStatistics \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "organizationalUnitIds": [
    "00000000-0000-0000-0000-000000000000"
  ],
  "bundleIds": [
    0
  ]
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/OrganizationalUnitsLastAssessmentStatistics',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AssessmentHistoryV2/OrganizationalUnitsLastAssessmentStatistics', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AssessmentHistoryV2/OrganizationalUnitsLastAssessmentStatistics

Get last assessment statistics for selected Organizational Units and bundles.

Body parameter

{
  "organizationalUnitIds": [
    "00000000-0000-0000-0000-000000000000"
  ],
  "bundleIds": [
    0
  ]
}

Parameters

Parameter In Type Required Description
body body OrganizationalUnitAssessmentHistoryRequestModel true none

Example responses

200 Response

[
  {
    "organizationalUnitPaths": [
      "string"
    ],
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "bundleId": 0,
    "statistics": {
      "passed": 0,
      "logicallyTested": 0,
      "failed": 0,
      "failedTests": 0,
      "error": 0,
      "failedEntities": 0,
      "totalEntities": 0,
      "excludedTests": 0,
      "excludedFailedTests": 0,
      "excludedRules": 0
    },
    "resultId": 0,
    "resultDate": "2020-05-27T12:08:18Z",
    "triggeredBy": "Unknown"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [OrganizationalUnitAssessmentHistory] none

Enumerated Values

Property Value
triggeredBy Unknown
triggeredBy ContinuousCompliancePolicy
triggeredBy Manual
triggeredBy SystemBundle
triggeredBy Serverless

Find Result Views By Time Range

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AssessmentHistoryV2/view/timeRange \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "creationTime": {
    "from": "2020-05-27T12:08:18Z",
    "to": "2020-05-27T12:08:18Z"
  },
  "pageSize": 1,
  "pageNumber": 1,
  "requestId": "00000000-0000-0000-0000-000000000000",
  "filterFields": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "sorting": {
    "fieldName": "string",
    "direction": 0
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/view/timeRange',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AssessmentHistoryV2/view/timeRange', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AssessmentHistoryV2/view/timeRange

Get assessment history (list of assessments) for specified time range and filters

Body parameter

{
  "creationTime": {
    "from": "2020-05-27T12:08:18Z",
    "to": "2020-05-27T12:08:18Z"
  },
  "pageSize": 1,
  "pageNumber": 1,
  "requestId": "00000000-0000-0000-0000-000000000000",
  "filterFields": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "sorting": {
    "fieldName": "string",
    "direction": 0
  }
}

Parameters

Parameter In Type Required Description
body body AssessmentViewsByTimeRangeRequest true details of the results to get (filters, time range)

Example responses

200 Response

{
  "results": [
    {
      "createdTime": "2020-05-27T12:08:18Z",
      "id": 0,
      "triggeredBy": "Unknown",
      "assessmentPassed": true,
      "hasErrors": true,
      "stats": {
        "passed": 0,
        "failed": 0,
        "error": 0,
        "failedTests": 0,
        "logicallyTested": 0,
        "failedEntities": 0,
        "excludedTests": 0,
        "excludedFailedTests": 0,
        "excludedRules": 0
      },
      "request": {
        "isTemplate": true,
        "id": 0,
        "name": "string",
        "description": "string",
        "cft": {
          "rootName": "string",
          "params": [
            {
              "key": "string",
              "value": "string"
            }
          ],
          "files": [
            {
              "name": "string",
              "template": "string"
            }
          ]
        },
        "isCft": true,
        "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
        "externalCloudAccountId": "string",
        "cloudAccountId": "string",
        "region": "string",
        "cloudNetwork": "string",
        "cloudAccountType": "Aws",
        "requestId": "00000000-0000-0000-0000-000000000000"
      },
      "hasDataSyncStatusIssues": true
    }
  ],
  "totalResultsCount": 0,
  "pageNumber": 0,
  "pageSize": 0,
  "requestId": "00000000-0000-0000-0000-000000000000"
}

Responses

Status Meaning Description Schema
200 OK OK AssessnentHistoryViewResultsTimeRange

Get View History

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/view/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/view/{id}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/view/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/view/{id}

Get result statistics for a specific assessment

Parameters

Parameter In Type Required Description
id path integer(int64) true The ID of the assessment

Example responses

200 Response

{
  "createdTime": "2020-05-27T12:08:18Z",
  "id": 0,
  "triggeredBy": "Unknown",
  "assessmentPassed": true,
  "hasErrors": true,
  "stats": {
    "passed": 0,
    "failed": 0,
    "error": 0,
    "failedTests": 0,
    "logicallyTested": 0,
    "failedEntities": 0,
    "excludedTests": 0,
    "excludedFailedTests": 0,
    "excludedRules": 0
  },
  "request": {
    "isTemplate": true,
    "id": 0,
    "name": "string",
    "description": "string",
    "cft": {
      "rootName": "string",
      "params": [
        {
          "key": "string",
          "value": "string"
        }
      ],
      "files": [
        {
          "name": "string",
          "template": "string"
        }
      ]
    },
    "isCft": true,
    "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
    "externalCloudAccountId": "string",
    "cloudAccountId": "string",
    "region": "string",
    "cloudNetwork": "string",
    "cloudAccountType": "Aws",
    "requestId": "00000000-0000-0000-0000-000000000000"
  },
  "hasDataSyncStatusIssues": true
}

Responses

Status Meaning Description Schema
200 OK OK AssessmentHistoryViewResultV2

Get Assessment Result Csv

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/csv/{assessmentResultId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/csv/{assessmentResultId}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/csv/{assessmentResultId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/csv/{assessmentResultId}

Get assessment result CSV

Parameters

Parameter In Type Required Description
assessmentResultId path integer(int64) true Assessment result ID

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get Assessment Result

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AssessmentHistoryV2/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AssessmentHistoryV2/{id}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AssessmentHistoryV2/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AssessmentHistoryV2/{id}

Get results for a specific assessment

Parameters

Parameter In Type Required Description
id path integer(int64) true the id of the assessment

Example responses

200 Response

{
  "triggeredBy": "Unknown",
  "tests": [
    {
      "error": "string",
      "testedCount": 0,
      "relevantCount": 0,
      "nonComplyingCount": 0,
      "exclusionStats": {
        "testedCount": 0,
        "relevantCount": 0,
        "nonComplyingCount": 0
      },
      "entityResults": [
        {
          "validationStatus": "Relevant",
          "isRelevant": true,
          "isValid": true,
          "isExcluded": true,
          "exclusionId": "00000000-0000-0000-0000-000000000000",
          "remediationId": "00000000-0000-0000-0000-000000000000",
          "error": "string",
          "testObj": {}
        }
      ],
      "rule": {
        "name": "string",
        "severity": "Informational",
        "logic": "string",
        "description": "string",
        "remediation": "string",
        "complianceTag": "string",
        "domain": "string",
        "priority": "string",
        "controlTitle": "string",
        "ruleId": "string",
        "logicHash": "string",
        "isDefault": true
      },
      "testPassed": true
    }
  ],
  "testEntities": {
    "notSupported": [
      {}
    ],
    "instance": [
      {}
    ],
    "securityGroup": [
      {}
    ],
    "elb": [
      {}
    ],
    "rds": [
      {}
    ],
    "lambda": [
      {}
    ],
    "region": [
      {}
    ],
    "virtualMachine": [
      {}
    ],
    "networkSecurityGroup": [
      {}
    ],
    "cloudTrail": [
      {}
    ],
    "nacl": [
      {}
    ],
    "vpc": [
      {}
    ],
    "subnet": [
      {}
    ],
    "s3Bucket": [
      {}
    ],
    "applicationLoadBalancer": [
      {}
    ],
    "iamUser": [
      {}
    ],
    "iamRole": [
      {}
    ],
    "iam": [
      {}
    ],
    "redshift": [
      {}
    ],
    "kms": [
      {}
    ],
    "default": [
      {}
    ],
    "vmInstance": [
      {}
    ],
    "iamGroup": [
      {}
    ],
    "efs": [
      {}
    ],
    "network": [
      {}
    ],
    "elastiCache": [
      {}
    ],
    "loadBalancer": [
      {}
    ],
    "vNet": [
      {}
    ],
    "sqldb": [
      {}
    ],
    "redisCache": [
      {}
    ],
    "applicationGateway": [
      {}
    ],
    "resourceGroup": [
      {}
    ],
    "sqlServer": [
      {}
    ],
    "ecsCluster": [
      {}
    ],
    "keyVault": [
      {}
    ],
    "networkLoadBalancer": [
      {}
    ],
    "networkInterface": [
      {}
    ],
    "ecsTaskDefinition": [
      {}
    ],
    "iamPolicy": [
      {}
    ],
    "volume": [
      {}
    ],
    "cloudFront": [
      {}
    ],
    "kinesis": [
      {}
    ],
    "iamServerCertificate": [
      {}
    ],
    "route53HostedZone": [
      {}
    ],
    "route53RecordSetGroup": [
      {}
    ],
    "acmCertificate": [
      {}
    ],
    "route53Domain": [
      {}
    ],
    "storageAccount": [
      {}
    ],
    "dynamoDbTable": [
      {}
    ],
    "ami": [
      {}
    ],
    "vpnGateway": [
      {}
    ],
    "virtualMfaDevices": [
      {}
    ],
    "internetGateway": [
      {}
    ],
    "wafRegional": [
      {}
    ],
    "lock": [
      {}
    ],
    "vpnConnection": [
      {}
    ],
    "ecsTask": [
      {}
    ],
    "customerGateway": [
      {}
    ],
    "gcpSecurityGroup": [
      {}
    ],
    "elasticIP": [
      {}
    ],
    "iamInstanceProfile": [
      {}
    ],
    "storageBucket": [
      {}
    ],
    "ecsService": [
      {}
    ],
    "project": [
      {}
    ],
    "serviceAccount": [
      {}
    ],
    "kmsKeyRing": [
      {}
    ],
    "dataWarehouse": [
      {}
    ],
    "guardDutyDetector": [
      {}
    ],
    "gcpIamPolicy": [
      {}
    ],
    "gcpIamUser": [
      {}
    ],
    "apiGateway": [
      {}
    ],
    "gcpGsuiteUser": [
      {}
    ],
    "gcpGsuiteGroup": [
      {}
    ],
    "gcpIamGroup": [
      {}
    ],
    "bigQuery": [
      {}
    ],
    "routeTable": [
      {}
    ],
    "gkeCluster": [
      {}
    ],
    "postgreSQL": [
      {}
    ],
    "vpcFlowLog": [
      {}
    ],
    "iamAccountSummary": [
      {}
    ],
    "sageMakerNotebook": [
      {}
    ],
    "containerRegistry": [
      {}
    ],
    "inspector": [
      {}
    ],
    "kmsAliases": [
      {}
    ],
    "passwordPolicy": [
      {}
    ],
    "configurationRecorder": [
      {}
    ],
    "cosmosDbAccount": [
      {}
    ],
    "networkWatcher": [
      {}
    ],
    "vpcPeeringConnection": [
      {}
    ],
    "metricAlarm": [
      {}
    ],
    "snsSubscription": [
      {}
    ],
    "logGroup": [
      {}
    ],
    "metricFilter": [
      {}
    ],
    "cloudWatchEventsRule": [
      {}
    ],
    "awsIamAccessKey": [
      {}
    ],
    "kubernetesNode": [
      {}
    ],
    "kubernetesPod": [
      {}
    ],
    "kubernetesService": [
      {}
    ],
    "logProfile": [
      {}
    ],
    "policyAssignment": [
      {}
    ],
    "kubernetesNetworkPolicy": [
      {}
    ],
    "kubernetesIngress": [
      {}
    ],
    "kubernetesPodSecurityPolicy": [
      {}
    ],
    "cloudSql": [
      {}
    ],
    "kubernetesKubelet": [
      {}
    ],
    "autoScalingGroup": [
      {}
    ],
    "elasticSearchDomain": [
      {}
    ],
    "logicEntity": [
      {}
    ],
    "vpcEndpoint": [
      {}
    ],
    "cloudFunction": [
      {}
    ],
    "logicApp": [
      {}
    ],
    "applicationSecurityGroup": [
      {}
    ],
    "awsCodeDependency": [
      {}
    ],
    "bigTable": [
      {}
    ],
    "kubernetesAccountMetadata": [
      {}
    ],
    "virtualMachineScaleSet": [
      {}
    ],
    "analysisServiceServer": [
      {}
    ],
    "emrCluster": [
      {}
    ],
    "aksCluster": [
      {}
    ],
    "pubSubTopic": [
      {}
    ],
    "pubSubSubscription": [
      {}
    ],
    "kubernetesImage": [
      {}
    ],
    "policyDefinition": [
      {}
    ],
    "eksCluster": [
      {}
    ],
    "sqs": [
      {}
    ],
    "kubernetesServiceAccount": [
      {}
    ],
    "kubernetesRole": [
      {}
    ],
    "kubernetesClusterRole": [
      {}
    ],
    "kubernetesRoleBinding": [
      {}
    ],
    "kubernetesClusterRoleBinding": [
      {}
    ],
    "snsTopic": [
      {}
    ],
    "webApp": [
      {}
    ],
    "functionApp": [
      {}
    ],
    "kubernetesCluster": [
      {}
    ],
    "kubernetesNamespace": [
      {}
    ],
    "organization": [
      {}
    ],
    "account": [
      {}
    ],
    "organizationUnit": [
      {}
    ],
    "user": [
      {}
    ],
    "userCredential": [
      {}
    ],
    "configSetting": [
      {}
    ]
  },
  "exclusions": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "ruleLogicHash": "string",
      "ruleName": "string",
      "ruleId": "string",
      "logic": "string",
      "bundleId": 0,
      "cloudAccountId": "00000000-0000-0000-0000-000000000000",
      "cloudAccountType": "Aws",
      "comment": "string"
    }
  ],
  "remediations": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "ruleLogicHash": "string",
      "ruleName": "string",
      "ruleId": "string",
      "logic": "string",
      "rulesetId": 0,
      "cloudAccountId": "00000000-0000-0000-0000-000000000000",
      "platform": "Aws",
      "comment": "string",
      "cloudBots": [
        "string"
      ]
    }
  ],
  "dataSyncStatus": [
    {
      "entityType": "NotSupported",
      "recentlySuccessfulSync": true,
      "generalFetchPermissionIssues": true,
      "entitiesWithPermissionIssues": [
        {
          "externalId": "string",
          "name": "string",
          "cloudVendorIdentifier": "string"
        }
      ]
    }
  ],
  "createdTime": "2020-05-27T12:08:18Z",
  "id": 0,
  "assessmentPassed": true,
  "hasErrors": true,
  "stats": {
    "passed": 0,
    "failed": 0,
    "error": 0,
    "failedTests": 0,
    "logicallyTested": 0,
    "failedEntities": 0,
    "excludedTests": 0,
    "excludedFailedTests": 0,
    "excludedRules": 0
  },
  "request": {
    "isTemplate": true,
    "id": 0,
    "name": "string",
    "description": "string",
    "cft": {
      "rootName": "string",
      "params": [
        {
          "key": "string",
          "value": "string"
        }
      ],
      "files": [
        {
          "name": "string",
          "template": "string"
        }
      ]
    },
    "isCft": true,
    "dome9CloudAccountId": "00000000-0000-0000-0000-000000000000",
    "externalCloudAccountId": "string",
    "cloudAccountId": "string",
    "region": "string",
    "cloudNetwork": "string",
    "cloudAccountType": "Aws",
    "requestId": "00000000-0000-0000-0000-000000000000"
  },
  "hasDataSyncStatusIssues": true
}

Responses

Status Meaning Description Schema
200 OK OK AssessmentHistoryResultV2

Delete Assessment Result

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AssessmentHistoryV2?historyId=0
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AssessmentHistoryV2?historyId=0',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AssessmentHistoryV2', params={
  'historyId': '0'
, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AssessmentHistoryV2

Delete an assessment

Parameters

Parameter In Type Required Description
historyId query integer(int64) true the id of the assessment

Responses

Status Meaning Description Schema
204 No Content No Content None

Audit

The Audit resource has methods to retrieve Dome9 audit events. Audit events are issues such as alerts, that can be generated as a result of activity on one of a user's managed cloud accounts, or as a result of a compliance assessment on a cloud account or environment.

There are different types of audit events, and different severities.

Audit events are retrieved in pages, from earliest to latest, according to the time period, and page size set in the request. Typically the GET method should be repeated for each page of the request, until all the requested events are retrieved. A user can only retrieve audit events for their own cloud accounts.

See also

Alerts

Audit trail

Audit Events & Types

Get Event Types

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/audit/event-types \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/audit/event-types',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/audit/event-types', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/audit/event-types

Get a list of available audit event types

Example responses

200 Response

{
  "property1": "string",
  "property2": "string"
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description

Get Audit Events For Aws Sec Group

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/audit/awsgroup/{groupId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/audit/awsgroup/{groupId}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/audit/awsgroup/{groupId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/audit/awsgroup/{groupId}

Get audit events for a specific AWS Security Group

Parameters

Parameter In Type Required Description
groupId path integer(int64) true the Security Group id
startTimestamp query string(date-time) false the time of the first event to be fetched
endTimestamp query string(date-time) false the time of the last event to be fetched

Example responses

200 Response

[
  {
    "id": {},
    "cell": [
      {}
    ],
    "metadata": {
      "property1": "string",
      "property2": "string"
    }
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AuditEntry] none

Export

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/audit/export \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/audit/export',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/audit/export', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/audit/export

Export an audit events report in a csv format

Parameters

Parameter In Type Required Description
startTimestamp query string(date-time) false the time of the first event to be exported in the report
endTimestamp query string(date-time) false the time of the last event to be exported in the report
userNameFilter query string false only events for this specific user will be exported
eventType query string false only events of this specific type will be exported

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/Audit?pageNum=0&eventsPerPage=0 \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/Audit?pageNum=0&eventsPerPage=0',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/Audit', params={
  'pageNum': '0',  'eventsPerPage': '0'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/Audit

Get audit events with optional filters

Parameters

Parameter In Type Required Description
pageNum query integer(int32) true page # in the sequence of audit pages
eventsPerPage query integer(int32) true no. of audit events in the page
startTimestamp query string(date-time) false the time of first audit to be fetched
endTimestamp query string(date-time) false the time of the last audit to be fetched
userName query string false only events for this specific user will be fetched
eventType query string false only events of this specific type will be fetched
fim query boolean false none

Example responses

200 Response

{
  "total": 0,
  "page": 0,
  "records": 0,
  "rows": [
    {
      "id": {},
      "cell": [
        {}
      ],
      "metadata": {
        "property1": "string",
        "property2": "string"
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Audit

Get Audit Event Metadata

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/Audit/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/Audit/{id}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/Audit/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/Audit/{id}

Get audit metadata

Parameters

Parameter In Type Required Description
id path string(uuid) true The audit event id

Example responses

200 Response

{
  "id": {},
  "cell": [
    {}
  ],
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK OK AuditEntry

AwsCloudConfiguration

Get By Id

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsCloudConfiguration/{cloudAccountId}

Get cloud configuration by cloud account id

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true none

Example responses

200 Response

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "enabled": true
}

Responses

Status Meaning Description Schema
200 OK OK AwsCloudConfiguration

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId}',
{
    method: 'POST',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AwsCloudConfiguration/{cloudAccountId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AwsCloudConfiguration/{cloudAccountId}

Add new cloud configuration

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true none

Example responses

200 Response

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "enabled": true
}

Responses

Status Meaning Description Schema
200 OK OK AwsCloudConfiguration

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsCloudConfiguration \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsCloudConfiguration',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsCloudConfiguration', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsCloudConfiguration

Get all cloud accounts with cloud configuration enabled or disabled

Example responses

200 Response

[
  {
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "enabled": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AwsCloudConfiguration] none

AwsSecurityGroup

Get All Referenced Security Groups

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsSecurityGroup/{id}/ReferencingGroups \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroup/{id}/ReferencingGroups',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsSecurityGroup/{id}/ReferencingGroups', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsSecurityGroup/{id}/ReferencingGroups

Get all referenced security groups

Parameters

Parameter In Type Required Description
id path string true Aws security group id

Example responses

200 Response

[
  {
    "externalId": "string",
    "regionId": "us_east_1",
    "securityGroupName": "string",
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "cloudAccountName": "string",
    "vpcId": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AwsSecurityGroup] none

Enumerated Values

Property Value
regionId us_east_1
regionId us_west_1
regionId eu_west_1
regionId ap_southeast_1
regionId ap_northeast_1
regionId us_west_2
regionId sa_east_1
regionId az_1_region_a_geo_1
regionId az_2_region_a_geo_1
regionId az_3_region_a_geo_1
regionId ap_southeast_2
regionId mellanox_region
regionId us_gov_west_1
regionId eu_central_1
regionId ap_northeast_2
regionId ap_south_1
regionId us_east_2
regionId ca_central_1
regionId eu_west_2
regionId eu_west_3
regionId eu_north_1
regionId cn_north_1
regionId cn_northwest_1
regionId us_gov_east_1
regionId ap_east_1
regionId me_south_1
regionId westus
regionId eastus
regionId eastus2
regionId northcentralus
regionId westus2
regionId southcentralus
regionId centralus
regionId usgovlowa
regionId usgovvirginia
regionId northeurope
regionId westeurope
regionId eastasia
regionId southeastasia
regionId japaneast
regionId japanwest
regionId brazilsouth
regionId australiaeast
regionId australiasoutheast
regionId centralindia
regionId southindia
regionId westindia
regionId canadaeast
regionId westcentralus
regionId chinaeast
regionId chinanorth
regionId canadacentral
regionId germanycentral
regionId germanynortheast
regionId koreacentral
regionId uksouth
regionId ukwest
regionId koreasouth
regionId francecentral
regionId francesouth
regionId germanywestcentral
regionId usdodcentral
regionId usdodeast
regionId usgovarizona
regionId usgovtexas
regionId australiacentral
regionId australiacentral2
regionId chinaeast2
regionId chinanorth2
regionId southafricanorth
regionId southafricawest
regionId uaecentral
regionId uaenorth
regionId ussecwest
regionId usseceast
regionId germanynorth
regionId switzerlandwest
regionId norwaywest
regionId norwayeast
regionId switzerlandnorth
regionId asia
regionId asia_east1
regionId asia_northeast1
regionId asia_south1
regionId asia_southeast1
regionId australia_southeast1
regionId europe
regionId europe_north1
regionId europe_west1
regionId europe_west2
regionId europe_west3
regionId europe_west4
regionId northamerica_northeast1
regionId southamerica_east1
regionId us
regionId us_central1
regionId us_east1
regionId us_east4
regionId us_west1
regionId us_west2
regionId global
regionId asia_east2
regionId eur4
regionId nam4
regionId europe_west6
regionId japan_west

Get All Security Groups

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsSecurityGroup \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroup',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsSecurityGroup', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsSecurityGroup

Get all Aws security group Entities

Example responses

200 Response

[
  {
    "externalId": "string",
    "regionId": "us_east_1",
    "securityGroupName": "string",
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "cloudAccountName": "string",
    "vpcId": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AwsSecurityGroup] none

Enumerated Values

Property Value
regionId us_east_1
regionId us_west_1
regionId eu_west_1
regionId ap_southeast_1
regionId ap_northeast_1
regionId us_west_2
regionId sa_east_1
regionId az_1_region_a_geo_1
regionId az_2_region_a_geo_1
regionId az_3_region_a_geo_1
regionId ap_southeast_2
regionId mellanox_region
regionId us_gov_west_1
regionId eu_central_1
regionId ap_northeast_2
regionId ap_south_1
regionId us_east_2
regionId ca_central_1
regionId eu_west_2
regionId eu_west_3
regionId eu_north_1
regionId cn_north_1
regionId cn_northwest_1
regionId us_gov_east_1
regionId ap_east_1
regionId me_south_1
regionId westus
regionId eastus
regionId eastus2
regionId northcentralus
regionId westus2
regionId southcentralus
regionId centralus
regionId usgovlowa
regionId usgovvirginia
regionId northeurope
regionId westeurope
regionId eastasia
regionId southeastasia
regionId japaneast
regionId japanwest
regionId brazilsouth
regionId australiaeast
regionId australiasoutheast
regionId centralindia
regionId southindia
regionId westindia
regionId canadaeast
regionId westcentralus
regionId chinaeast
regionId chinanorth
regionId canadacentral
regionId germanycentral
regionId germanynortheast
regionId koreacentral
regionId uksouth
regionId ukwest
regionId koreasouth
regionId francecentral
regionId francesouth
regionId germanywestcentral
regionId usdodcentral
regionId usdodeast
regionId usgovarizona
regionId usgovtexas
regionId australiacentral
regionId australiacentral2
regionId chinaeast2
regionId chinanorth2
regionId southafricanorth
regionId southafricawest
regionId uaecentral
regionId uaenorth
regionId ussecwest
regionId usseceast
regionId germanynorth
regionId switzerlandwest
regionId norwaywest
regionId norwayeast
regionId switzerlandnorth
regionId asia
regionId asia_east1
regionId asia_northeast1
regionId asia_south1
regionId asia_southeast1
regionId australia_southeast1
regionId europe
regionId europe_north1
regionId europe_west1
regionId europe_west2
regionId europe_west3
regionId europe_west4
regionId northamerica_northeast1
regionId southamerica_east1
regionId us
regionId us_central1
regionId us_east1
regionId us_east4
regionId us_west1
regionId us_west2
regionId global
regionId asia_east2
regionId eur4
regionId nam4
regionId europe_west6
regionId japan_west

AwsSecurityGroupPolicy

Get By Cloud Account

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{id}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsSecurityGroupPolicy/CloudAccount/{id}

Get all security groups policies of cloud account by cloud account id

Parameters

Parameter In Type Required Description
id path string(uuid) true cloud account id

Example responses

200 Response

[
  {
    "externalId": "string",
    "isProtected": true,
    "securityGroupName": "string",
    "description": "string",
    "vpcId": "string",
    "vpcName": "string",
    "regionId": "us_east_1",
    "cloudAccountId": "string",
    "cloudAccountName": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    },
    "securityGroupId": "00000000-0000-0000-0000-000000000000",
    "srl": "string",
    "inboundServices": [
      {
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outboundServices": [
      {
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [CloudSecurityGroupPolicy] none

Enumerated Values

Property Value
regionId us_east_1
regionId us_west_1
regionId eu_west_1
regionId ap_southeast_1
regionId ap_northeast_1
regionId us_west_2
regionId sa_east_1
regionId az_1_region_a_geo_1
regionId az_2_region_a_geo_1
regionId az_3_region_a_geo_1
regionId ap_southeast_2
regionId mellanox_region
regionId us_gov_west_1
regionId eu_central_1
regionId ap_northeast_2
regionId ap_south_1
regionId us_east_2
regionId ca_central_1
regionId eu_west_2
regionId eu_west_3
regionId eu_north_1
regionId cn_north_1
regionId cn_northwest_1
regionId us_gov_east_1
regionId ap_east_1
regionId me_south_1
regionId westus
regionId eastus
regionId eastus2
regionId northcentralus
regionId westus2
regionId southcentralus
regionId centralus
regionId usgovlowa
regionId usgovvirginia
regionId northeurope
regionId westeurope
regionId eastasia
regionId southeastasia
regionId japaneast
regionId japanwest
regionId brazilsouth
regionId australiaeast
regionId australiasoutheast
regionId centralindia
regionId southindia
regionId westindia
regionId canadaeast
regionId westcentralus
regionId chinaeast
regionId chinanorth
regionId canadacentral
regionId germanycentral
regionId germanynortheast
regionId koreacentral
regionId uksouth
regionId ukwest
regionId koreasouth
regionId francecentral
regionId francesouth
regionId germanywestcentral
regionId usdodcentral
regionId usdodeast
regionId usgovarizona
regionId usgovtexas
regionId australiacentral
regionId australiacentral2
regionId chinaeast2
regionId chinanorth2
regionId southafricanorth
regionId southafricawest
regionId uaecentral
regionId uaenorth
regionId ussecwest
regionId usseceast
regionId germanynorth
regionId switzerlandwest
regionId norwaywest
regionId norwayeast
regionId switzerlandnorth
regionId asia
regionId asia_east1
regionId asia_northeast1
regionId asia_south1
regionId asia_southeast1
regionId australia_southeast1
regionId europe
regionId europe_north1
regionId europe_west1
regionId europe_west2
regionId europe_west3
regionId europe_west4
regionId northamerica_northeast1
regionId southamerica_east1
regionId us
regionId us_central1
regionId us_east1
regionId us_east4
regionId us_west1
regionId us_west2
regionId global
regionId asia_east2
regionId eur4
regionId nam4
regionId europe_west6
regionId japan_west
protocolType ALL
protocolType HOPOPT
protocolType ICMP
protocolType IGMP
protocolType GGP
protocolType IPV4
protocolType ST
protocolType TCP
protocolType CBT
protocolType EGP
protocolType IGP
protocolType BBN_RCC_MON
protocolType NVP2
protocolType PUP
protocolType ARGUS
protocolType EMCON
protocolType XNET
protocolType CHAOS
protocolType UDP
protocolType MUX
protocolType DCN_MEAS
protocolType HMP
protocolType PRM
protocolType XNS_IDP
protocolType TRUNK1
protocolType TRUNK2
protocolType LEAF1
protocolType LEAF2
protocolType RDP
protocolType IRTP
protocolType ISO_TP4
protocolType NETBLT
protocolType MFE_NSP
protocolType MERIT_INP
protocolType DCCP
protocolType ThreePC
protocolType IDPR
protocolType XTP
protocolType DDP
protocolType IDPR_CMTP
protocolType TPplusplus
protocolType IL
protocolType IPV6
protocolType SDRP
protocolType IPV6_ROUTE
protocolType IPV6_FRAG
protocolType IDRP
protocolType RSVP
protocolType GRE
protocolType DSR
protocolType BNA
protocolType ESP
protocolType AH
protocolType I_NLSP
protocolType SWIPE
protocolType NARP
protocolType MOBILE
protocolType TLSP
protocolType SKIP
protocolType ICMPV6
protocolType IPV6_NONXT
protocolType IPV6_OPTS
protocolType CFTP
protocolType SAT_EXPAK
protocolType KRYPTOLAN
protocolType RVD
protocolType IPPC
protocolType SAT_MON
protocolType VISA
protocolType IPCV
protocolType CPNX
protocolType CPHB
protocolType WSN
protocolType PVP
protocolType BR_SAT_MON
protocolType SUN_ND
protocolType WB_MON
protocolType WB_EXPAK
protocolType ISO_IP
protocolType VMTP
protocolType SECURE_VMTP
protocolType VINES
protocolType TTP
protocolType NSFNET_IGP
protocolType DGP
protocolType TCF
protocolType EIGRP
protocolType OSPFIGP
protocolType SPRITE_RPC
protocolType LARP
protocolType MTP
protocolType AX25
protocolType IPIP
protocolType MICP
protocolType SCC_SP
protocolType ETHERIP
protocolType ENCAP
protocolType GMTP
protocolType IFMP
protocolType PNNI
protocolType PIM
protocolType ARIS
protocolType SCPS
protocolType QNX
protocolType AN
protocolType IPCOMP
protocolType SNP
protocolType COMPAQ_PEER
protocolType IPX_IN_IP
protocolType VRRP
protocolType PGM
protocolType L2TP
protocolType DDX
protocolType IATP
protocolType STP
protocolType SRP
protocolType UTI
protocolType SMP
protocolType SM
protocolType PTP
protocolType ISIS
protocolType FIRE
protocolType CRTP
protocolType CRUDP
protocolType SSCOPMCE
protocolType IPLT
protocolType SPS
protocolType PIPE
protocolType SCTP
protocolType FC
protocolType RSVP_E2E_IGNORE
protocolType MOBILITY_HEADER
protocolType UDPLITE
protocolType MPLS_IN_IP
protocolType MANET
protocolType HIP
protocolType SHIM6
protocolType WESP
protocolType ROHC
type CIDR
type DNS
type IPList
type MagicIP
type AWS
type Tag
type ASG
type CIDRv6
type PrefixList
icmpType All
icmpType EchoReply
icmpType DestinationUnreachable
icmpType SourceQuench
icmpType Redirect
icmpType AlternateHostAddress
icmpType Echo
icmpType RouterAdvertisement
icmpType RouterSelection
icmpType TimeExceeded
icmpType ParameterProblem
icmpType Timestamp
icmpType TimestampReply
icmpType InformationRequest
icmpType InformationReply
icmpType AddressMaskRequest
icmpType AddressMaskReply
icmpType Traceroute
icmpType DatagramConversionError
icmpType MobileHostRedirect
icmpType IPv6WhereAreYou
icmpType IPv6IAmHere
icmpType MobileRegistrationRequest
icmpType MobileRegistrationReply
icmpType DomainNameRequest
icmpType DomainNameReply
icmpType SKIP
icmpType Photuris
icmpv6Type All

Get By External Security Group Id

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}

Get security group policy by external security group id and cloud account id

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id

Example responses

200 Response

{
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  },
  "securityGroupId": "00000000-0000-0000-0000-000000000000",
  "srl": "string",
  "inboundServices": [
    {
      "id": "string",
      "name": "string",
      "description": "string",
      "protocolType": "ALL",
      "port": "string",
      "openForAll": true,
      "scope": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "icmpType": "All",
      "icmpv6Type": "All"
    }
  ],
  "outboundServices": [
    {
      "id": "string",
      "name": "string",
      "description": "string",
      "protocolType": "ALL",
      "port": "string",
      "openForAll": true,
      "scope": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "icmpType": "All",
      "icmpv6Type": "All"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK CloudSecurityGroupPolicy

Delete Cloud Security Group

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}

Delete an AWS security group

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id

Responses

Status Meaning Description Schema
204 No Content No Content None

Post Protection Mode

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/ProtectionMode \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "protectionMode": "FullManage"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/ProtectionMode',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/ProtectionMode', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/ProtectionMode

Update protection mode to security group

Body parameter

{
  "protectionMode": "FullManage"
}

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id
body body CloudSecurityGroupProtectionModeChange true protectionMode: FullManage / ReadOnly

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Update Service In Security Group

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}

Update a service (rule) for an AWS security group

Body parameter

{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id
policyType path string true the service type (Inbound / Outbound)
body body CloudSecurityGroupService true updated details for the service

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Add Service To Security Group

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}

Creat a new Service (rule) for the security group

Body parameter

{
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id
policyType path string true the service type (Inbound / Outbound))
body body CloudSecurityGroupPolicyService true details for the service

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete Service From Security Group

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}/{serviceId}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}/{serviceId}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}/{serviceId}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AwsSecurityGroupPolicy/CloudAccount/{cloudAccountId}/Policy/{externalId}/Services/{policyType}/{serviceId}

Delete a service (rule) from an AWS security group

Parameters

Parameter In Type Required Description
cloudAccountId path string(uuid) true Cloud account id
externalId path string true Aws security group id
policyType path string true the service type (Inbound / Outbound)
serviceId path string true the service id

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Responses

Status Meaning Description Schema
204 No Content No Content None

Get All Security Groups Of Account

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AwsSecurityGroupPolicy \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AwsSecurityGroupPolicy', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AwsSecurityGroupPolicy

Get a list of all security groups

Example responses

200 Response

[
  {
    "externalId": "string",
    "isProtected": true,
    "securityGroupName": "string",
    "description": "string",
    "vpcId": "string",
    "vpcName": "string",
    "regionId": "us_east_1",
    "cloudAccountId": "string",
    "cloudAccountName": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    },
    "securityGroupId": "00000000-0000-0000-0000-000000000000",
    "srl": "string",
    "inboundServices": [
      {
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outboundServices": [
      {
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [CloudSecurityGroupPolicy] none

Enumerated Values

Property Value
regionId us_east_1
regionId us_west_1
regionId eu_west_1
regionId ap_southeast_1
regionId ap_northeast_1
regionId us_west_2
regionId sa_east_1
regionId az_1_region_a_geo_1
regionId az_2_region_a_geo_1
regionId az_3_region_a_geo_1
regionId ap_southeast_2
regionId mellanox_region
regionId us_gov_west_1
regionId eu_central_1
regionId ap_northeast_2
regionId ap_south_1
regionId us_east_2
regionId ca_central_1
regionId eu_west_2
regionId eu_west_3
regionId eu_north_1
regionId cn_north_1
regionId cn_northwest_1
regionId us_gov_east_1
regionId ap_east_1
regionId me_south_1
regionId westus
regionId eastus
regionId eastus2
regionId northcentralus
regionId westus2
regionId southcentralus
regionId centralus
regionId usgovlowa
regionId usgovvirginia
regionId northeurope
regionId westeurope
regionId eastasia
regionId southeastasia
regionId japaneast
regionId japanwest
regionId brazilsouth
regionId australiaeast
regionId australiasoutheast
regionId centralindia
regionId southindia
regionId westindia
regionId canadaeast
regionId westcentralus
regionId chinaeast
regionId chinanorth
regionId canadacentral
regionId germanycentral
regionId germanynortheast
regionId koreacentral
regionId uksouth
regionId ukwest
regionId koreasouth
regionId francecentral
regionId francesouth
regionId germanywestcentral
regionId usdodcentral
regionId usdodeast
regionId usgovarizona
regionId usgovtexas
regionId australiacentral
regionId australiacentral2
regionId chinaeast2
regionId chinanorth2
regionId southafricanorth
regionId southafricawest
regionId uaecentral
regionId uaenorth
regionId ussecwest
regionId usseceast
regionId germanynorth
regionId switzerlandwest
regionId norwaywest
regionId norwayeast
regionId switzerlandnorth
regionId asia
regionId asia_east1
regionId asia_northeast1
regionId asia_south1
regionId asia_southeast1
regionId australia_southeast1
regionId europe
regionId europe_north1
regionId europe_west1
regionId europe_west2
regionId europe_west3
regionId europe_west4
regionId northamerica_northeast1
regionId southamerica_east1
regionId us
regionId us_central1
regionId us_east1
regionId us_east4
regionId us_west1
regionId us_west2
regionId global
regionId asia_east2
regionId eur4
regionId nam4
regionId europe_west6
regionId japan_west
protocolType ALL
protocolType HOPOPT
protocolType ICMP
protocolType IGMP
protocolType GGP
protocolType IPV4
protocolType ST
protocolType TCP
protocolType CBT
protocolType EGP
protocolType IGP
protocolType BBN_RCC_MON
protocolType NVP2
protocolType PUP
protocolType ARGUS
protocolType EMCON
protocolType XNET
protocolType CHAOS
protocolType UDP
protocolType MUX
protocolType DCN_MEAS
protocolType HMP
protocolType PRM
protocolType XNS_IDP
protocolType TRUNK1
protocolType TRUNK2
protocolType LEAF1
protocolType LEAF2
protocolType RDP
protocolType IRTP
protocolType ISO_TP4
protocolType NETBLT
protocolType MFE_NSP
protocolType MERIT_INP
protocolType DCCP
protocolType ThreePC
protocolType IDPR
protocolType XTP
protocolType DDP
protocolType IDPR_CMTP
protocolType TPplusplus
protocolType IL
protocolType IPV6
protocolType SDRP
protocolType IPV6_ROUTE
protocolType IPV6_FRAG
protocolType IDRP
protocolType RSVP
protocolType GRE
protocolType DSR
protocolType BNA
protocolType ESP
protocolType AH
protocolType I_NLSP
protocolType SWIPE
protocolType NARP
protocolType MOBILE
protocolType TLSP
protocolType SKIP
protocolType ICMPV6
protocolType IPV6_NONXT
protocolType IPV6_OPTS
protocolType CFTP
protocolType SAT_EXPAK
protocolType KRYPTOLAN
protocolType RVD
protocolType IPPC
protocolType SAT_MON
protocolType VISA
protocolType IPCV
protocolType CPNX
protocolType CPHB
protocolType WSN
protocolType PVP
protocolType BR_SAT_MON
protocolType SUN_ND
protocolType WB_MON
protocolType WB_EXPAK
protocolType ISO_IP
protocolType VMTP
protocolType SECURE_VMTP
protocolType VINES
protocolType TTP
protocolType NSFNET_IGP
protocolType DGP
protocolType TCF
protocolType EIGRP
protocolType OSPFIGP
protocolType SPRITE_RPC
protocolType LARP
protocolType MTP
protocolType AX25
protocolType IPIP
protocolType MICP
protocolType SCC_SP
protocolType ETHERIP
protocolType ENCAP
protocolType GMTP
protocolType IFMP
protocolType PNNI
protocolType PIM
protocolType ARIS
protocolType SCPS
protocolType QNX
protocolType AN
protocolType IPCOMP
protocolType SNP
protocolType COMPAQ_PEER
protocolType IPX_IN_IP
protocolType VRRP
protocolType PGM
protocolType L2TP
protocolType DDX
protocolType IATP
protocolType STP
protocolType SRP
protocolType UTI
protocolType SMP
protocolType SM
protocolType PTP
protocolType ISIS
protocolType FIRE
protocolType CRTP
protocolType CRUDP
protocolType SSCOPMCE
protocolType IPLT
protocolType SPS
protocolType PIPE
protocolType SCTP
protocolType FC
protocolType RSVP_E2E_IGNORE
protocolType MOBILITY_HEADER
protocolType UDPLITE
protocolType MPLS_IN_IP
protocolType MANET
protocolType HIP
protocolType SHIM6
protocolType WESP
protocolType ROHC
type CIDR
type DNS
type IPList
type MagicIP
type AWS
type Tag
type ASG
type CIDRv6
type PrefixList
icmpType All
icmpType EchoReply
icmpType DestinationUnreachable
icmpType SourceQuench
icmpType Redirect
icmpType AlternateHostAddress
icmpType Echo
icmpType RouterAdvertisement
icmpType RouterSelection
icmpType TimeExceeded
icmpType ParameterProblem
icmpType Timestamp
icmpType TimestampReply
icmpType InformationRequest
icmpType InformationReply
icmpType AddressMaskRequest
icmpType AddressMaskReply
icmpType Traceroute
icmpType DatagramConversionError
icmpType MobileHostRedirect
icmpType IPv6WhereAreYou
icmpType IPv6IAmHere
icmpType MobileRegistrationRequest
icmpType MobileRegistrationReply
icmpType DomainNameRequest
icmpType DomainNameReply
icmpType SKIP
icmpType Photuris
icmpv6Type All

Create Aws Security Group

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AwsSecurityGroupPolicy \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AwsSecurityGroupPolicy',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AwsSecurityGroupPolicy', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AwsSecurityGroupPolicy

Create a new AWS security group

Body parameter

{
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter In Type Required Description
body body CloudSecurityGroupBase true details for the new AWS security group

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

AzureCloudAccount

The AzureCloudAccounts resource has methods to onboard Azure cloud accounts to Dome9 and to manage some of their settings. It is can be used to automatically or programatically onboard Azure accounts into a Dome9 account, or to set global settings such as the Region Configuration (used for network security management).

See also

Onboard an Azure Subscription to Dome9

Delete Force

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AzureCloudAccount/{id}/DeleteForce
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/DeleteForce',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AzureCloudAccount/{id}/DeleteForce', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AzureCloudAccount/{id}/DeleteForce

Delete an Azure account from a Dome9 account (the Azure account is not deleted from Azure) and linked entities

Parameters

Parameter In Type Required Description
id path string(uuid) true the Dome9 account id for the account

Responses

Status Meaning Description Schema
204 No Content No Content None

Get Missing Permissions

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AzureCloudAccount/{id}/MissingPermissions

Get a list of missing permissions for a specific Azure account in a Dome9 account

Parameters

Parameter In Type Required Description
id path string(uuid) true the account id for the Azure account in Dome9

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "actions": [
    {
      "type": "string",
      "subType": "string",
      "total": 0,
      "error": {
        "code": "string",
        "message": "string"
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK CloudAccountMissingPermissions

Get Mising Permissions By Entity Type

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/EntityType?entityType=string \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/EntityType?entityType=string',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/EntityType', params={
  'entityType': 'string'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AzureCloudAccount/{id}/MissingPermissions/EntityType

Get a list of missing permissions for a specific cloud entity type and Azure cloud account

Parameters

Parameter In Type Required Description
id path string(uuid) true the account id for the Azure account in Dome9
entityType query string true the entity type
subType query string false the entity subtype

Example responses

200 Response

[
  {
    "srl": "string",
    "consecutiveFails": 0,
    "lastFail": "2020-05-27T12:08:18Z",
    "lastSuccess": "2020-05-27T12:08:18Z",
    "firstFail": "2020-05-27T12:08:18Z",
    "lastFailErrorCode": "string",
    "lastFailMessage": "string",
    "id": "00000000-0000-0000-0000-000000000000",
    "retryMetadata": {
      "permissions": [
        "string"
      ],
      "entityType": "string",
      "subType": "string"
    },
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "vendor": "aws"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [MissingPermission] none

Enumerated Values

Property Value
vendor aws
vendor hp
vendor mellanox
vendor awsgov
vendor azure
vendor google
vendor awschina
vendor azuregov
vendor kubernetes
vendor azurechina

Reset Missing Permissions

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/Reset
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/Reset',
{
    method: 'PUT'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/{id}/MissingPermissions/Reset', params={

, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/{id}/MissingPermissions/Reset

Reset (re-validate) the missing permissions indication for an Azure account in Dome9

Parameters

Parameter In Type Required Description
id path string(uuid) true the account id for the Azure account in Dome9

Responses

Status Meaning Description Schema
204 No Content No Content None

Update Operation Mode

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/{id}/OperationMode \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "operationMode": "Read"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/OperationMode',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/{id}/OperationMode', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/{id}/OperationMode

Update the operations mode for an Azure account in Dome9. Modes can be Read-Only or Manage

Body parameter

{
  "operationMode": "Read"
}

Parameters

Parameter In Type Required Description
id path string(uuid) true the account id for the Azure account in Dome9
body body AzureAccountOperationMode true updated details for the account, including the operations mode

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureCloudAccount

Update Account Name

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/{id}/AccountName \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "name": "string"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/AccountName',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/{id}/AccountName', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/{id}/AccountName

Update the account name (in Dome9) for an Azure account

Body parameter

{
  "name": "string"
}

Parameters

Parameter In Type Required Description
id path string(uuid) true the account id in Dome9
body body AzureAccountNameMode true the new name for the account

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureCloudAccount

Update Cloud Account Credentials

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/{id}/Credentials \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "applicationId": "string",
  "applicationKey": "string"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/Credentials',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/{id}/Credentials', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/{id}/Credentials

Body parameter

{
  "applicationId": "string",
  "applicationKey": "string"
}

Parameters

Parameter In Type Required Description
id path string(uuid) true none
body body AzureCloudAccountCredentialsPut true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Update Organziational Id

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/{id}/organizationalUnit \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/organizationalUnit',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/{id}/organizationalUnit', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/{id}/organizationalUnit

Update the ID of the Organizational Unit that this cloud account will be attached to. Use 'null' for th root organizational unit

Body parameter

{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
id path string(uuid) true The Dome9 Guid ID of the Azure cloud account
body body UpdateIdViewModel2 true The Guid ID of the Organizational Unit to attach to. Use 'null' to attach to the root Organizational Unit

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureCloudAccount

Move Cloud Accounts To Organizational Unit

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/move \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "sourceOrganizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "targetOrganizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/move',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/move', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/organizationalUnit/move

Detach cloud accounts from an Organizational unit and attach them to another Organizational unit. Use 'null' for root organizational unit

Body parameter

{
  "sourceOrganizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "targetOrganizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body MoveOrganizationalUnit true The guids of the source organizational unit to detach from and the target organizational unit to attach to. Use null for root organizational unit.

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Move All Cloud Accounts To Organizational Unit

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/moveAll \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/moveAll',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/moveAll', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureCloudAccount/organizationalUnit/moveAll

Detach all cloud accounts from their current organizational unit and attach them to a new one. Default is to root organizational unit

Body parameter

{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body UpdateId true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Post Attach Multi

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/attach \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "entries": [
    "string"
  ],
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/attach',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AzureCloudAccount/organizationalUnit/attach', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AzureCloudAccount/organizationalUnit/attach

Attach several cloud accounts to a specific Organizational Unit. User 'null' as root Organizational Unit as target

Body parameter

{
  "entries": [
    "string"
  ],
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body AttachCloudAccounts true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Sync Now

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AzureCloudAccount/{id}/SyncNow \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount/{id}/SyncNow',
{
    method: 'POST',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AzureCloudAccount/{id}/SyncNow', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AzureCloudAccount/{id}/SyncNow

Parameters

Parameter In Type Required Description
id path string(uuid) true none

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureCloudAccount

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AzureCloudAccount \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AzureCloudAccount', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AzureCloudAccount

Get details for all Azure accounts for the Dome9 user

Example responses

200 Response

[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "name": "string",
    "subscriptionId": "string",
    "tenantId": "string",
    "credentials": {
      "clientId": "string",
      "clientPassword": "string"
    },
    "operationMode": "Read",
    "error": "string",
    "creationDate": "2020-05-27T12:08:18Z",
    "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
    "organizationalUnitPath": "string",
    "organizationalUnitName": "string",
    "vendor": "aws",
    "magellan": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AzureCloudAccount] none

Enumerated Values

Property Value
operationMode Read
operationMode Manage
vendor aws
vendor hp
vendor mellanox
vendor awsgov
vendor azure
vendor google
vendor awschina
vendor azuregov
vendor kubernetes
vendor azurechina

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AzureCloudAccount/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AzureCloudAccount/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AzureCloudAccount/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AzureCloudAccount/{id}

Delete an Azure account from a Dome9 account (the Azure account is not deleted from Azure)

Parameters

Parameter In Type Required Description
id path string(uuid) true the Dome9 account id for the account

Responses

Status Meaning Description Schema
204 No Content No Content None

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AzureCloudAccount \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureCloudAccount',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AzureCloudAccount', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AzureCloudAccount

Add (onboard) an Azure account to the user's Dome9 account

Body parameter

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "subscriptionId": "string",
  "tenantId": "string",
  "credentials": {
    "clientId": "string",
    "clientPassword": "string"
  },
  "operationMode": "Read",
  "error": "string",
  "creationDate": "2020-05-27T12:08:18Z",
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "vendor": "aws",
  "magellan": true
}

Parameters

Parameter In Type Required Description
body body AzureCloudAccount true details for the Azure account

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

AzureSecurityGroupPolicy

The AzureSecurityGroupPolicy resource has methods to add and manage Azure security group policies for Azure cloud accounts that are managed by Dome9. Among the managment operations are methods to add services (rules) to security groups.

See also

Azure Network Security Groups

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AzureSecurityGroupPolicy \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AzureSecurityGroupPolicy', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AzureSecurityGroupPolicy

Get a list of all Network Security Group Policies for the Azure accounts in the Dome9 account

Example responses

200 Response

[
  {
    "tags": [
      {
        "key": "string",
        "value": "string"
      }
    ],
    "id": "00000000-0000-0000-0000-000000000000",
    "externalSecurityGroupId": "string",
    "accountId": 0,
    "cloudAccountName": "string",
    "lastUpdatedByDome9": true,
    "error": {
      "action": "string",
      "errorMessage": "string"
    },
    "inboundServices": [
      {
        "direction": "string",
        "name": "string",
        "description": "string",
        "priority": 0,
        "access": "string",
        "protocol": "string",
        "sourcePortRanges": [
          "string"
        ],
        "sourceScopes": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "destinationPortRanges": [
          "string"
        ],
        "destinationScopes": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "isDefault": true
      }
    ],
    "outboundServices": [
      {
        "direction": "string",
        "name": "string",
        "description": "string",
        "priority": 0,
        "access": "string",
        "protocol": "string",
        "sourcePortRanges": [
          "string"
        ],
        "sourceScopes": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "destinationPortRanges": [
          "string"
        ],
        "destinationScopes": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "isDefault": true
      }
    ],
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "name": "string",
    "description": "string",
    "region": "string",
    "resourceGroup": "string",
    "isTamperProtected": true
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AzureSgPolicyGet] none

Enumerated Values

Property Value
type CIDR
type DNS
type IPList
type MagicIP
type AWS
type Tag
type ASG
type CIDRv6
type PrefixList

Put

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "inboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id}',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureSecurityGroupPolicy/{id}

Update a security group policy

Body parameter

{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "inboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}

Parameters

Parameter In Type Required Description
id path string(uuid) true the security group policy id
body body AzureSgPolicyPost true details for the policy, including the changes

Example responses

200 Response

{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "id": "00000000-0000-0000-0000-000000000000",
  "externalSecurityGroupId": "string",
  "accountId": 0,
  "cloudAccountName": "string",
  "lastUpdatedByDome9": true,
  "error": {
    "action": "string",
    "errorMessage": "string"
  },
  "inboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureSgPolicyGet

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/AzureSecurityGroupPolicy/{id}

Delete a security group policy

Parameters

Parameter In Type Required Description
id path string(uuid) true the security group policy id

Responses

Status Meaning Description Schema
204 No Content No Content None

Update Protection Mode

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/AzureSecurityGroupPolicy/{policyId}/TamperProtected?tamperProtected=true \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{policyId}/TamperProtected?tamperProtected=true',
{
    method: 'PUT',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/AzureSecurityGroupPolicy/{policyId}/TamperProtected', params={
  'tamperProtected': 'true'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/AzureSecurityGroupPolicy/{policyId}/TamperProtected

Enable or disable Tamper Protetion for a specific security group policy

Parameters

Parameter In Type Required Description
policyId path string(uuid) true the security group policy id>
tamperProtected query boolean true enable/disable Tamper protection

Example responses

200 Response

{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "id": "00000000-0000-0000-0000-000000000000",
  "externalSecurityGroupId": "string",
  "accountId": 0,
  "cloudAccountName": "string",
  "lastUpdatedByDome9": true,
  "error": {
    "action": "string",
    "errorMessage": "string"
  },
  "inboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureSgPolicyGet

Get Stats

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/AzureSecurityGroupPolicy/Stats \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy/Stats',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/AzureSecurityGroupPolicy/Stats', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/AzureSecurityGroupPolicy/Stats

Get statistics for the security group policies for the Dome9 user

Example responses

200 Response

[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "name": "string",
    "resourceGroup": "string",
    "region": "string",
    "cloudAccountName": "string",
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "isTamperProtected": true,
    "alertsCount": 0
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [AzureSgPolicyStats] none

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/AzureSecurityGroupPolicy \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "inboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/AzureSecurityGroupPolicy',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/AzureSecurityGroupPolicy', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/AzureSecurityGroupPolicy

Create a security group policy

Body parameter

{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "inboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}

Parameters

Parameter In Type Required Description
body body AzureSgPolicyPost true details for the policy

Example responses

200 Response

{
  "tags": [
    {
      "key": "string",
      "value": "string"
    }
  ],
  "id": "00000000-0000-0000-0000-000000000000",
  "externalSecurityGroupId": "string",
  "accountId": 0,
  "cloudAccountName": "string",
  "lastUpdatedByDome9": true,
  "error": {
    "action": "string",
    "errorMessage": "string"
  },
  "inboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "outboundServices": [
    {
      "direction": "string",
      "name": "string",
      "description": "string",
      "priority": 0,
      "access": "string",
      "protocol": "string",
      "sourcePortRanges": [
        "string"
      ],
      "sourceScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "destinationPortRanges": [
        "string"
      ],
      "destinationScopes": [
        {
          "type": "CIDR",
          "data": {
            "property1": "string",
            "property2": "string"
          }
        }
      ],
      "isDefault": true
    }
  ],
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "region": "string",
  "resourceGroup": "string",
  "isTamperProtected": true
}

Responses

Status Meaning Description Schema
200 OK OK AzureSgPolicyGet

CloudAccounts

The CloudAccounts resource has methods to onboard AWS cloud accounts to Dome9 and to manage some of their settings. It is can be used to automatically or programatically onboard AWS accounts into a Dome9 account, or to set global settings such as the Region Configuration (used for network security management).

See also

Cloud Accounts

Use-Case: Onboard an AWS account to Dome9

Delete Force

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/cloudaccounts/{id}/DeleteForce
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/cloudaccounts/{id}/DeleteForce',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/cloudaccounts/{id}/DeleteForce', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/cloudaccounts/{id}/DeleteForce

Delete an AWS cloud account and linked entities.

Parameters

Parameter In Type Required Description
id path string(uuid) true The Dome9 AWS account id (UUID)

Responses

Status Meaning Description Schema
204 No Content No Content None

Update Cloud Account Name

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/name \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": "string"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/name',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/name', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/name

Update an AWS cloud account name.

Body parameter

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": "string"
}

Parameters

Parameter In Type Required Description
body body String_ true the new name for the account

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Update Cloud Account Region Conf

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/region-conf \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": {
    "region": "us_east_1",
    "name": "string",
    "hidden": true,
    "newGroupBehavior": "ReadOnly"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/region-conf',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/region-conf', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/region-conf

Update an AWS cloud account region configuration.

Body parameter

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": {
    "region": "us_east_1",
    "name": "string",
    "hidden": true,
    "newGroupBehavior": "ReadOnly"
  }
}

Parameters

Parameter In Type Required Description
body body CloudAccountRegionConfigurationViewModel_ true updated Regional Configuration parameters for the account

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Update Cloud Account Credentials

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/credentials \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/credentials',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/credentials', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/credentials

Update credentials for an AWS cloud account in Dome9. At least one of the following properties must be provided: "cloudAccountId", "externalAccountNumber"

Body parameter

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "externalAccountNumber": "string",
  "data": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  }
}

Parameters

Parameter In Type Required Description
body body CloudAccountCredentialsViewModel_ true credentials block

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get Missing Permissions

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/cloudaccounts/{id}/MissingPermissions

Get a list of missing permissions for a specific account. These are permissions needed by Dome9 to manage accounts.

Parameters

Parameter In Type Required Description
id path string(uuid) true none

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "actions": [
    {
      "type": "string",
      "subType": "string",
      "total": 0,
      "error": {
        "code": "string",
        "message": "string"
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK CloudAccountMissingPermissions

Get Mising Permissions By Entity Type

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/EntityType?entityType=string \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/EntityType?entityType=string',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/EntityType', params={
  'entityType': 'string'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/cloudaccounts/{id}/MissingPermissions/EntityType

Get a list of missing permissions for a specific cloud entity type and cloud account

Parameters

Parameter In Type Required Description
id path string(uuid) true The account id
entityType query string true The entity type
subType query string false The entity subtype (optional)

Example responses

200 Response

[
  {
    "srl": "string",
    "consecutiveFails": 0,
    "lastFail": "2020-05-27T12:08:18Z",
    "lastSuccess": "2020-05-27T12:08:18Z",
    "firstFail": "2020-05-27T12:08:18Z",
    "lastFailErrorCode": "string",
    "lastFailMessage": "string",
    "id": "00000000-0000-0000-0000-000000000000",
    "retryMetadata": {
      "permissions": [
        "string"
      ],
      "entityType": "string",
      "subType": "string"
    },
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "vendor": "aws"
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [MissingPermission] none

Enumerated Values

Property Value
vendor aws
vendor hp
vendor mellanox
vendor awsgov
vendor azure
vendor google
vendor awschina
vendor azuregov
vendor kubernetes
vendor azurechina

Reset Missing Permissions

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/Reset
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/Reset',
{
    method: 'PUT'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.put('https://api.dome9.com/v2/cloudaccounts/{id}/MissingPermissions/Reset', params={

, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/{id}/MissingPermissions/Reset

reset (re-validate) an account

Parameters

Parameter In Type Required Description
id path string(uuid) true The account id

Responses

Status Meaning Description Schema
204 No Content No Content None

Sync Now

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/cloudaccounts/{id}/SyncNow \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/{id}/SyncNow',
{
    method: 'POST',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/cloudaccounts/{id}/SyncNow', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/cloudaccounts/{id}/SyncNow

Send a data sync command to immediately fetch cloud account data into Dome9's system caches. This API is used in conjunction with EntityFetchStatus API resource to query the fetch status. Read more and see a full example here: https://github.com/Dome9/Python_API_SDK/blob/master/implementation/runSyncAssessment.md

Parameters

Parameter In Type Required Description
id path string(uuid) true The account id.

Example responses

200 Response

{
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "externalAccountNumber": "string",
  "workFlowId": "00000000-0000-0000-0000-000000000000"
}

Responses

Status Meaning Description Schema
200 OK OK AwsSyncNowResult

Update Organziational Id

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/{id}/organizationalUnit \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/{id}/organizationalUnit',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/{id}/organizationalUnit', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/{id}/organizationalUnit

Update the ID of the Organizational Unit that this cloud account will be attached to. Use 'null' for the root Organizational Unit

Body parameter

{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
id path string(uuid) true The Dome9 Guid ID of the AWS cloud account
body body UpdateIdViewModel2 true The Guid ID of the Organizational Unit to attach to. Use 'null' to attach to the root Organizational Unit

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "vendor": "aws",
  "name": "string",
  "externalAccountNumber": "string",
  "error": "string",
  "isFetchingSuspended": true,
  "creationDate": "2020-05-27T12:08:18Z",
  "credentials": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  },
  "iamSafe": {
    "awsGroupArn": "string",
    "awsPolicyArn": "string",
    "mode": "OptIn",
    "state": "Enabled",
    "excludedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    },
    "restrictedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    }
  },
  "netSec": {
    "regions": [
      {
        "region": "us_east_1",
        "name": "string",
        "hidden": true,
        "newGroupBehavior": "ReadOnly"
      }
    ]
  },
  "magellan": true,
  "fullProtection": true,
  "allowReadOnly": true,
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "lambdaScanner": true,
  "serverless": {
    "codeAnalyzerEnabled": true,
    "codeDependencyAnalyzerEnabled": true
  },
  "serverlessEnabled": true
}

Responses

Status Meaning Description Schema
200 OK OK CloudAccount

Move Cloud Accounts To Organizational Unit

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/organizationalUnit/move \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "sourceOrganizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "targetOrganizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/move',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/move', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/organizationalUnit/move

Detach cloud accounts from an Organizational unit and attach them to another Organizational unit Use 'null' for root organizational unit

Body parameter

{
  "sourceOrganizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "targetOrganizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body MoveOrganizationalUnit true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Move All Cloud Accounts To Organizational Unit

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudaccounts/organizationalUnit/moveAll \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/moveAll',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/moveAll', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudaccounts/organizationalUnit/moveAll

Detach all cloud accounts from their current organizational unit and attach them to a new one. Default is to root organizational unit

Body parameter

{
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body UpdateId true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Post Attach Multi

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/cloudaccounts/organizationalUnit/attach \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "entries": [
    "string"
  ],
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/attach',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/cloudaccounts/organizationalUnit/attach', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/cloudaccounts/organizationalUnit/attach

Attach several cloud accounts to a specific Organizational Unit. User 'null' as root Organizational Unit as target

Body parameter

{
  "entries": [
    "string"
  ],
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000"
}

Parameters

Parameter In Type Required Description
body body AttachCloudAccounts true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/CloudAccounts/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/CloudAccounts/{id}',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/CloudAccounts/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/CloudAccounts/{id}

Fetch a specific AWS cloud account

Parameters

Parameter In Type Required Description
id path string true The Dome9 AWS account id (UUID) or the AWS external account number (12 digit number)

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "vendor": "aws",
  "name": "string",
  "externalAccountNumber": "string",
  "error": "string",
  "isFetchingSuspended": true,
  "creationDate": "2020-05-27T12:08:18Z",
  "credentials": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  },
  "iamSafe": {
    "awsGroupArn": "string",
    "awsPolicyArn": "string",
    "mode": "OptIn",
    "state": "Enabled",
    "excludedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    },
    "restrictedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    }
  },
  "netSec": {
    "regions": [
      {
        "region": "us_east_1",
        "name": "string",
        "hidden": true,
        "newGroupBehavior": "ReadOnly"
      }
    ]
  },
  "magellan": true,
  "fullProtection": true,
  "allowReadOnly": true,
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "lambdaScanner": true,
  "serverless": {
    "codeAnalyzerEnabled": true,
    "codeDependencyAnalyzerEnabled": true
  },
  "serverlessEnabled": true
}

Responses

Status Meaning Description Schema
200 OK OK CloudAccount

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/CloudAccounts \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "id": "00000000-0000-0000-0000-000000000000",
  "vendor": "aws",
  "name": "string",
  "externalAccountNumber": "string",
  "error": "string",
  "isFetchingSuspended": true,
  "creationDate": "2020-05-27T12:08:18Z",
  "credentials": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  },
  "iamSafe": {
    "awsGroupArn": "string",
    "awsPolicyArn": "string",
    "mode": "OptIn",
    "state": "Enabled",
    "excludedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    },
    "restrictedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    }
  },
  "netSec": {
    "regions": [
      {
        "region": "us_east_1",
        "name": "string",
        "hidden": true,
        "newGroupBehavior": "ReadOnly"
      }
    ]
  },
  "magellan": true,
  "fullProtection": true,
  "allowReadOnly": true,
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "lambdaScanner": true,
  "serverless": {
    "codeAnalyzerEnabled": true,
    "codeDependencyAnalyzerEnabled": true
  },
  "serverlessEnabled": true
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/CloudAccounts',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/CloudAccounts', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/CloudAccounts

Add a new AWS cloud account to Dome9
Onboarding an AWS cloud account requires granting Dome9 permissions to access the account.
The following document describes the required procedure: https://helpcenter.dome9.com/hc/en-us/articles/360003994613-Onboard-an-AWS-Account

Body parameter

{
  "id": "00000000-0000-0000-0000-000000000000",
  "vendor": "aws",
  "name": "string",
  "externalAccountNumber": "string",
  "error": "string",
  "isFetchingSuspended": true,
  "creationDate": "2020-05-27T12:08:18Z",
  "credentials": {
    "apikey": "string",
    "arn": "string",
    "secret": "string",
    "iamUser": "string",
    "type": "UserBased",
    "isReadOnly": true
  },
  "iamSafe": {
    "awsGroupArn": "string",
    "awsPolicyArn": "string",
    "mode": "OptIn",
    "state": "Enabled",
    "excludedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    },
    "restrictedIamEntities": {
      "rolesArns": [
        "string"
      ],
      "usersArns": [
        "string"
      ]
    }
  },
  "netSec": {
    "regions": [
      {
        "region": "us_east_1",
        "name": "string",
        "hidden": true,
        "newGroupBehavior": "ReadOnly"
      }
    ]
  },
  "magellan": true,
  "fullProtection": true,
  "allowReadOnly": true,
  "organizationalUnitId": "00000000-0000-0000-0000-000000000000",
  "organizationalUnitPath": "string",
  "organizationalUnitName": "string",
  "lambdaScanner": true,
  "serverless": {
    "codeAnalyzerEnabled": true,
    "codeDependencyAnalyzerEnabled": true
  },
  "serverlessEnabled": true
}

Parameters

Parameter In Type Required Description
body body CloudAccount true The new AWS account data

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/CloudAccounts/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/CloudAccounts/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/CloudAccounts/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/CloudAccounts/{id}

Delete an AWS cloud account.

Parameters

Parameter In Type Required Description
id path string(uuid) true The Dome9 AWS account id (UUID)

Responses

Status Meaning Description Schema
204 No Content No Content None

CloudSecurityGroup

The CloudSecurityGroup resource has methods to add and manage security groups in a cloud account that is managed by Dome9. Among the managment operations are methods to add services (rules) to security groups.

Use the CloudAccounts resource to set a cloud account to Protected (managed).

CloudAccounts

CloudInstance

See also

Security Groups

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/CloudSecurityGroup?cloudAccountId=string®ionId=string \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/CloudSecurityGroup?cloudAccountId=string®ionId=string',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/CloudSecurityGroup', params={
  'cloudAccountId': 'string',  'regionId': 'string'
}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/CloudSecurityGroup

Get AWS security groups for a specific cloud account and region

Parameters

Parameter In Type Required Description
cloudAccountId query string(uuid) true the cloud account id
regionId query string true the region

Example responses

200 Response

[
  {
    "securityGroupId": 0,
    "services": {
      "inbound": [
        {
          "inbound": true,
          "id": "string",
          "name": "string",
          "description": "string",
          "protocolType": "ALL",
          "port": "string",
          "openForAll": true,
          "scope": [
            {
              "type": "CIDR",
              "data": {
                "property1": "string",
                "property2": "string"
              }
            }
          ],
          "icmpType": "All",
          "icmpv6Type": "All"
        }
      ],
      "outbound": [
        {
          "inbound": true,
          "id": "string",
          "name": "string",
          "description": "string",
          "protocolType": "ALL",
          "port": "string",
          "openForAll": true,
          "scope": [
            {
              "type": "CIDR",
              "data": {
                "property1": "string",
                "property2": "string"
              }
            }
          ],
          "icmpType": "All",
          "icmpv6Type": "All"
        }
      ]
    },
    "externalId": "string",
    "isProtected": true,
    "securityGroupName": "string",
    "description": "string",
    "vpcId": "string",
    "vpcName": "string",
    "regionId": "us_east_1",
    "cloudAccountId": "string",
    "cloudAccountName": "string",
    "tags": {
      "property1": "string",
      "property2": "string"
    }
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [CloudSecurityGroup] none

Enumerated Values

Property Value
protocolType ALL
protocolType HOPOPT
protocolType ICMP
protocolType IGMP
protocolType GGP
protocolType IPV4
protocolType ST
protocolType TCP
protocolType CBT
protocolType EGP
protocolType IGP
protocolType BBN_RCC_MON
protocolType NVP2
protocolType PUP
protocolType ARGUS
protocolType EMCON
protocolType XNET
protocolType CHAOS
protocolType UDP
protocolType MUX
protocolType DCN_MEAS
protocolType HMP
protocolType PRM
protocolType XNS_IDP
protocolType TRUNK1
protocolType TRUNK2
protocolType LEAF1
protocolType LEAF2
protocolType RDP
protocolType IRTP
protocolType ISO_TP4
protocolType NETBLT
protocolType MFE_NSP
protocolType MERIT_INP
protocolType DCCP
protocolType ThreePC
protocolType IDPR
protocolType XTP
protocolType DDP
protocolType IDPR_CMTP
protocolType TPplusplus
protocolType IL
protocolType IPV6
protocolType SDRP
protocolType IPV6_ROUTE
protocolType IPV6_FRAG
protocolType IDRP
protocolType RSVP
protocolType GRE
protocolType DSR
protocolType BNA
protocolType ESP
protocolType AH
protocolType I_NLSP
protocolType SWIPE
protocolType NARP
protocolType MOBILE
protocolType TLSP
protocolType SKIP
protocolType ICMPV6
protocolType IPV6_NONXT
protocolType IPV6_OPTS
protocolType CFTP
protocolType SAT_EXPAK
protocolType KRYPTOLAN
protocolType RVD
protocolType IPPC
protocolType SAT_MON
protocolType VISA
protocolType IPCV
protocolType CPNX
protocolType CPHB
protocolType WSN
protocolType PVP
protocolType BR_SAT_MON
protocolType SUN_ND
protocolType WB_MON
protocolType WB_EXPAK
protocolType ISO_IP
protocolType VMTP
protocolType SECURE_VMTP
protocolType VINES
protocolType TTP
protocolType NSFNET_IGP
protocolType DGP
protocolType TCF
protocolType EIGRP
protocolType OSPFIGP
protocolType SPRITE_RPC
protocolType LARP
protocolType MTP
protocolType AX25
protocolType IPIP
protocolType MICP
protocolType SCC_SP
protocolType ETHERIP
protocolType ENCAP
protocolType GMTP
protocolType IFMP
protocolType PNNI
protocolType PIM
protocolType ARIS
protocolType SCPS
protocolType QNX
protocolType AN
protocolType IPCOMP
protocolType SNP
protocolType COMPAQ_PEER
protocolType IPX_IN_IP
protocolType VRRP
protocolType PGM
protocolType L2TP
protocolType DDX
protocolType IATP
protocolType STP
protocolType SRP
protocolType UTI
protocolType SMP
protocolType SM
protocolType PTP
protocolType ISIS
protocolType FIRE
protocolType CRTP
protocolType CRUDP
protocolType SSCOPMCE
protocolType IPLT
protocolType SPS
protocolType PIPE
protocolType SCTP
protocolType FC
protocolType RSVP_E2E_IGNORE
protocolType MOBILITY_HEADER
protocolType UDPLITE
protocolType MPLS_IN_IP
protocolType MANET
protocolType HIP
protocolType SHIM6
protocolType WESP
protocolType ROHC
type CIDR
type DNS
type IPList
type MagicIP
type AWS
type Tag
type ASG
type CIDRv6
type PrefixList
icmpType All
icmpType EchoReply
icmpType DestinationUnreachable
icmpType SourceQuench
icmpType Redirect
icmpType AlternateHostAddress
icmpType Echo
icmpType RouterAdvertisement
icmpType RouterSelection
icmpType TimeExceeded
icmpType ParameterProblem
icmpType Timestamp
icmpType TimestampReply
icmpType InformationRequest
icmpType InformationReply
icmpType AddressMaskRequest
icmpType AddressMaskReply
icmpType Traceroute
icmpType DatagramConversionError
icmpType MobileHostRedirect
icmpType IPv6WhereAreYou
icmpType IPv6IAmHere
icmpType MobileRegistrationRequest
icmpType MobileRegistrationReply
icmpType DomainNameRequest
icmpType DomainNameReply
icmpType SKIP
icmpType Photuris
icmpv6Type All
regionId us_east_1
regionId us_west_1
regionId eu_west_1
regionId ap_southeast_1
regionId ap_northeast_1
regionId us_west_2
regionId sa_east_1
regionId az_1_region_a_geo_1
regionId az_2_region_a_geo_1
regionId az_3_region_a_geo_1
regionId ap_southeast_2
regionId mellanox_region
regionId us_gov_west_1
regionId eu_central_1
regionId ap_northeast_2
regionId ap_south_1
regionId us_east_2
regionId ca_central_1
regionId eu_west_2
regionId eu_west_3
regionId eu_north_1
regionId cn_north_1
regionId cn_northwest_1
regionId us_gov_east_1
regionId ap_east_1
regionId me_south_1
regionId westus
regionId eastus
regionId eastus2
regionId northcentralus
regionId westus2
regionId southcentralus
regionId centralus
regionId usgovlowa
regionId usgovvirginia
regionId northeurope
regionId westeurope
regionId eastasia
regionId southeastasia
regionId japaneast
regionId japanwest
regionId brazilsouth
regionId australiaeast
regionId australiasoutheast
regionId centralindia
regionId southindia
regionId westindia
regionId canadaeast
regionId westcentralus
regionId chinaeast
regionId chinanorth
regionId canadacentral
regionId germanycentral
regionId germanynortheast
regionId koreacentral
regionId uksouth
regionId ukwest
regionId koreasouth
regionId francecentral
regionId francesouth
regionId germanywestcentral
regionId usdodcentral
regionId usdodeast
regionId usgovarizona
regionId usgovtexas
regionId australiacentral
regionId australiacentral2
regionId chinaeast2
regionId chinanorth2
regionId southafricanorth
regionId southafricawest
regionId uaecentral
regionId uaenorth
regionId ussecwest
regionId usseceast
regionId germanynorth
regionId switzerlandwest
regionId norwaywest
regionId norwayeast
regionId switzerlandnorth
regionId asia
regionId asia_east1
regionId asia_northeast1
regionId asia_south1
regionId asia_southeast1
regionId australia_southeast1
regionId europe
regionId europe_north1
regionId europe_west1
regionId europe_west2
regionId europe_west3
regionId europe_west4
regionId northamerica_northeast1
regionId southamerica_east1
regionId us
regionId us_central1
regionId us_east1
regionId us_east4
regionId us_west1
regionId us_west2
regionId global
regionId asia_east2
regionId eur4
regionId nam4
regionId europe_west6
regionId japan_west

Put

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudsecuritygroup/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{id}',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudsecuritygroup/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudsecuritygroup/{id}

Update an AWS security group

Body parameter

{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter In Type Required Description
id path string true the AWS security group id (Dome9 Internal Id / AWS Security group id)
body body CloudSecurityGroup true updated details for the security group

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete Cloud Security Group

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/cloudsecuritygroup/{id}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/cloudsecuritygroup/{id}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/cloudsecuritygroup/{id}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/cloudsecuritygroup/{id}

Delete an AWS security group

Parameters

Parameter In Type Required Description
id path string true the AWS security group id (Dome9 Internal Id / AWS Security group id)

Responses

Status Meaning Description Schema
204 No Content No Content None

Update Sec Group

Code samples

# You can also use wget
curl -X PATCH https://api.dome9.com/v2/cloudsecuritygroup/{id} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{id}',
{
    method: 'PATCH',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json'
}

r = requests.patch('https://api.dome9.com/v2/cloudsecuritygroup/{id}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PATCH /v2/cloudsecuritygroup/{id}

Updates an AWS security group protection mode

Body parameter

{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter In Type Required Description
id path integer(int64) true the AWS security group id
body body CloudSecurityGroup true updated details for the security group. only 'IsProtected' is used in this call which defines whether to protect or unprotect the security group.

Responses

Status Meaning Description Schema
204 No Content No Content None

Change Protection Mode

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/cloudsecuritygroup/{id}/protection-mode \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "protectionMode": "FullManage"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{id}/protection-mode',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/cloudsecuritygroup/{id}/protection-mode', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/cloudsecuritygroup/{id}/protection-mode

Change the protection mode for an AWS security group

Body parameter

{
  "protectionMode": "FullManage"
}

Parameters

Parameter In Type Required Description
id path string true the AWS security group id (Dome9 internal ID / AWS security group ID)
body body CloudSecurityGroupProtectionModeChange true details for the security group, including the protection mode. Only 'ProtectionMode' is required in this call (FullManage or ReadOnly).

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Update a Security Group's Service

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/cloudsecuritygroup/{groupid}/services/{policyType}

Update a service (rule) for an AWS security group

Body parameter

{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}

Parameters

Parameter In Type Required Description
groupid path string true the security group id (Dome9 internal ID / AWS security group id)
policyType path string true the service type (Inbound / Outbound)
body body CloudSecurityGroupService true updated details for the service

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Add a service(rule) to a Security Group

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType} \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/cloudsecuritygroup/{groupid}/services/{policyType}

Creat a new Service (rule) for the security group

Body parameter

{
  "inbound": true,
  "id": "string",
  "name": "string",
  "description": "string",
  "protocolType": "ALL",
  "port": "string",
  "openForAll": true,
  "scope": [
    {
      "type": "CIDR",
      "data": {
        "property1": "string",
        "property2": "string"
      }
    }
  ],
  "icmpType": "All",
  "icmpv6Type": "All"
}

Parameters

Parameter In Type Required Description
groupid path string true the security group id (Dome9 internal ID / AWS security group id)
policyType path string true the service type (Inbound / Outbound))
body body CloudSecurityGroupService true details for the service

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Delete a Security Group's Service

Code samples

# You can also use wget
curl -X DELETE https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}/{serviceid}
  --basic -u <key-id>:<key-secret> \


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

request('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}/{serviceid}',
{
    method: 'DELETE'

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


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

r = requests.delete('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/services/{policyType}/{serviceid}', params={

, auth=(apiKey, apiSecret))

print(r.json())

DELETE /v2/cloudsecuritygroup/{groupid}/services/{policyType}/{serviceid}

Delete a service from an AWS security group

Parameters

Parameter In Type Required Description
groupid path string true the security group id (Dome9 internal ID / AWS security group id)
policyType path string true the service type (Inbound / Outbound)
serviceid path string true the service id

Enumerated Values

Parameter Value
policyType Inbound
policyType Outbound

Responses

Status Meaning Description Schema
204 No Content No Content None

Update Tags

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/tags \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/tags',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/tags', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/cloudsecuritygroup/{groupid}/tags

Update the list of tags for an AWS securitry group

Body parameter

{
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter In Type Required Description
groupid path string true the security group id (Dome9 internal ID / AWS security group id)
body body CloudSecurityGroupTagsChange true the updated list of tags and their values

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Get Security Group Revision History

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/history \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/history',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/cloudsecuritygroup/{groupid}/history', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/cloudsecuritygroup/{groupid}/history

Get the list of group revisions and their corresponding events for an AWS security group.

Parameters

Parameter In Type Required Description
groupid path string true the security group id (Dome9 internal ID / AWS security group id)
limit query integer(int32) false max number of revisions to return

Example responses

200 Response

[
  {
    "accountId": 0,
    "externalAccountNumber": "string",
    "region": "us_east_1",
    "vpc": "string",
    "revisionId": 0,
    "timestamp": "2020-05-27T12:08:18Z",
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "cloudSecurityGroup": {},
    "auditEvent": {}
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [CloudSecurityGroupRevision] none

Enumerated Values

Property Value
region us_east_1
region us_west_1
region eu_west_1
region ap_southeast_1
region ap_northeast_1
region us_west_2
region sa_east_1
region az_1_region_a_geo_1
region az_2_region_a_geo_1
region az_3_region_a_geo_1
region ap_southeast_2
region mellanox_region
region us_gov_west_1
region eu_central_1
region ap_northeast_2
region ap_south_1
region us_east_2
region ca_central_1
region eu_west_2
region eu_west_3
region eu_north_1
region cn_north_1
region cn_northwest_1
region us_gov_east_1
region ap_east_1
region me_south_1
region westus
region eastus
region eastus2
region northcentralus
region westus2
region southcentralus
region centralus
region usgovlowa
region usgovvirginia
region northeurope
region westeurope
region eastasia
region southeastasia
region japaneast
region japanwest
region brazilsouth
region australiaeast
region australiasoutheast
region centralindia
region southindia
region westindia
region canadaeast
region westcentralus
region chinaeast
region chinanorth
region canadacentral
region germanycentral
region germanynortheast
region koreacentral
region uksouth
region ukwest
region koreasouth
region francecentral
region francesouth
region germanywestcentral
region usdodcentral
region usdodeast
region usgovarizona
region usgovtexas
region australiacentral
region australiacentral2
region chinaeast2
region chinanorth2
region southafricanorth
region southafricawest
region uaecentral
region uaenorth
region ussecwest
region usseceast
region germanynorth
region switzerlandwest
region norwaywest
region norwayeast
region switzerlandnorth
region asia
region asia_east1
region asia_northeast1
region asia_south1
region asia_southeast1
region australia_southeast1
region europe
region europe_north1
region europe_west1
region europe_west2
region europe_west3
region europe_west4
region northamerica_northeast1
region southamerica_east1
region us
region us_central1
region us_east1
region us_east4
region us_west1
region us_west2
region global
region asia_east2
region eur4
region nam4
region europe_west6
region japan_west

Create Cloud Security Group

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/CloudSecurityGroup \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/CloudSecurityGroup',
{
    method: 'POST',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('https://api.dome9.com/v2/CloudSecurityGroup', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

POST /v2/CloudSecurityGroup

Create a new AWS security group

Body parameter

{
  "securityGroupId": 0,
  "services": {
    "inbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ],
    "outbound": [
      {
        "inbound": true,
        "id": "string",
        "name": "string",
        "description": "string",
        "protocolType": "ALL",
        "port": "string",
        "openForAll": true,
        "scope": [
          {
            "type": "CIDR",
            "data": {
              "property1": "string",
              "property2": "string"
            }
          }
        ],
        "icmpType": "All",
        "icmpv6Type": "All"
      }
    ]
  },
  "externalId": "string",
  "isProtected": true,
  "securityGroupName": "string",
  "description": "string",
  "vpcId": "string",
  "vpcName": "string",
  "regionId": "us_east_1",
  "cloudAccountId": "string",
  "cloudAccountName": "string",
  "tags": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter In Type Required Description
body body CloudSecurityGroup true details for the new AWS security group

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

ComplianceRemediation

Compliance Remediation

Get

Code samples

# You can also use wget
curl -X GET https://api.dome9.com/v2/ComplianceRemediation \
  --basic -u <key-id>:<key-secret> \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const headers = {
    'Authorization': 'Basic ' + auth,
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/ComplianceRemediation',
{
    method: 'GET',
    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.dome9.com/v2/ComplianceRemediation', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

GET /v2/ComplianceRemediation

Get a list of remediations for the account

Example responses

200 Response

[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "ruleLogicHash": "string",
    "ruleName": "string",
    "ruleId": "string",
    "logic": "string",
    "rulesetId": 0,
    "cloudAccountId": "00000000-0000-0000-0000-000000000000",
    "platform": "Aws",
    "comment": "string",
    "cloudBots": [
      "string"
    ]
  }
]

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Description
anonymous [RemediationGet] none

Enumerated Values

Property Value
platform Aws
platform Azure
platform Google
platform Kubernetes

Put

Code samples

# You can also use wget
curl -X PUT https://api.dome9.com/v2/ComplianceRemediation \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecret := // Your API secret
    jsonReq := `` // Set data if needed

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Basic "+basicAuth(apiKey, apiSecret)},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.dome9.com/v2/AccessLease", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf(string(body))

    _ = err
}

func basicAuth(username string, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

const request = require('node-fetch');
var apiKey = // Your API key
var apiSecret = // Your API secret
var auth = (new Buffer(apiKey + ":" + apiSecret)).toString('base64')

const inputBody = '{
  "id": "00000000-0000-0000-0000-000000000000",
  "ruleLogicHash": "string",
  "ruleName": "string",
  "ruleId": "string",
  "logic": "string",
  "rulesetId": 0,
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "platform": "Aws",
  "comment": "string",
  "cloudBots": [
    "string"
  ]
}';
const headers = {
    'Authorization': 'Basic ' + auth,
    'Content-Type':'application/json',
    'Accept':'application/json'
};

request('https://api.dome9.com/v2/ComplianceRemediation',
{
    method: 'PUT',
  body: inputBody,    headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


import requests

# Your API key
apiKey =

# Your API secret
apiSecret =

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('https://api.dome9.com/v2/ComplianceRemediation', params={

}, headers = headers, auth=(apiKey, apiSecret))

print(r.json())

PUT /v2/ComplianceRemediation

Update a remediation

Body parameter

{
  "id": "00000000-0000-0000-0000-000000000000",
  "ruleLogicHash": "string",
  "ruleName": "string",
  "ruleId": "string",
  "logic": "string",
  "rulesetId": 0,
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "platform": "Aws",
  "comment": "string",
  "cloudBots": [
    "string"
  ]
}

Parameters

Parameter In Type Required Description
body body RemediationGet true details for the remediation

Example responses

200 Response

{
  "id": "00000000-0000-0000-0000-000000000000",
  "ruleLogicHash": "string",
  "ruleName": "string",
  "ruleId": "string",
  "logic": "string",
  "rulesetId": 0,
  "cloudAccountId": "00000000-0000-0000-0000-000000000000",
  "platform": "Aws",
  "comment": "string",
  "cloudBots": [
    "string"
  ]
}

Responses

Status Meaning Description Schema
200 OK OK RemediationGet

Post

Code samples

# You can also use wget
curl -X POST https://api.dome9.com/v2/ComplianceRemediation \
  --basic -u <key-id>:<key-secret> \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


package main

import (
    "bytes"
    "encoding/base64"
    "net/http"
    "fmt"
    "io/ioutil"
)

func main() {
    apiKey := // Your API key
    apiSecre