ASPM

The ASPM (Application Security Posture Management) service collection provides operations for executing queryLanguage functions across ASPM data. Run count queries, time-series queries, and services queries to analyze application security posture data.

Language	Last Update
Python	v1.6.1
PowerShell	v2.2.9
Go	v0.20.0
TypeScript	v0.6.0
Rust	v0.7.0
Ruby	v1.2.0

Operation	Description
ExecuteFunctionDataCount `execute_function_data_count`	A selected list of queryLanguage count queries.
ExecuteFunctionsCount `execute_functions_count`	A selected list of queryLanguage count queries.
ExecuteFunctionDataQueryCount `execute_function_data_query_count`	A selected list of queryLanguage count queries.
ExecuteFunctionsQueryCount `execute_functions_query_count`	A selected list of queryLanguage count queries.
ExecuteFunctionData `execute_function_data`	A selected list of queryLanguage queries.
ExecuteFunctionsOvertime `execute_functions_over_time`	A selected list of queryLanguage overtime queries.
ExecuteFunctions `execute_functions`	A selected list of queryLanguage services queries.
ExecuteFunctionDataQuery `execute_function_data_query`	A selected list of queryLanguage queries.
ExecuteFunctionsQueryOvertime `execute_functions_query_over_time`	A selected list of queryLanguage overtime queries.
ExecuteFunctionsQuery `execute_functions_query`	A selected list of queryLanguage services queries.
getServiceArtifacts `get_service_artifacts`	Retrieve service artifacts.
UpsertBusinessApplications `update_business_applications`	Create or Update Business Applications
GetCloudSecurityIntegrationState `get_cloud_security_integration_state`	Get Cloud Security integration state.
SetCloudSecurityIntegrationState `set_cloud_security_integration_state`	Set Cloud Security integration state.
GetExecutorNodes `get_executor_nodes`	Get all the relay nodes
UpdateExecutorNode `update_executor_node`	Update an existing relay node
CreateExecutorNode `create_executor_node`	Create a new relay node
GetExecutorNodesMetadata `get_executor_nodes_metadata`	Get metadata about all executor nodes.
DeleteExecutorNode `delete_node`	Delete a relay node
RetrieveRelayInstances `retrieve_relay_instances`	Retrieve the relay instances in CSV format.
GetIntegrationTasks `get_integration_tasks`	Get all the integration tasks
CreateIntegrationTask `create_integration_task`	Create new integration task.
GetIntegrationTasksMetadata `get_integration_tasks_metadata`	Get metadata about all integration tasks.
GetIntegrationTasksV2 `get_integration_tasks_v2`	Get all the integration tasks.
UpdateIntegrationTask `update_integration_task`	Update an existing integration task by its ID
DeleteIntegrationTask `delete_integration_task`	Delete an existing integration task by its ID
RunIntegrationTask `run_integration_task`	Run an integration task by its ID
RunIntegrationTaskAdmin `run_integration_task_admin`	Run an integration task by its ID with admin scope.
RunIntegrationTaskV2 `run_integration_task_v2`	Run an integration task by its ID
GetIntegrationTypes `get_integration_types`	Get all the integration types
GetIntegrations `get_integrations`	Get a list of all the integrations
CreateIntegration `create_integration`	Create a new integration
GetIntegrationsV2 `get_integrations_v2`	Get a list of all the integrations.
UpdateIntegration `update_integration`	Update an existing integration by its ID
DeleteIntegration `delete_integration`	Delete an existing integration by its ID
ExecuteQuery `execute_query`	Execute a query. The syntax used is identical to that of the query page.
ServiceNowGetDeployments `get_servicenow_deployments`	Retrieve ServiceNow deployments
ServiceNowGetServices `get_servicenow_services`	Retrieve ServiceNow services.
GetServicesCount `get_services_count`	Get the total amount of existing services
GetServiceViolationTypes `get_service_violation_types`	Get the different types of violation
GetTags `get_tags`	Get all the tags
UpsertTags `update_tags`	Create new or update existing tag. You can update unique tags table or regular tags table
DeleteTags `delete_tags`	Remove existing tags
DeleteGroup `delete_group`
GetGroupHierarchy `get_group_hierarchy`	Get group hierarchy
GetGroupV2 `get_group_v2`	Get group details
GetGroupsV2 `get_groups_v2`
GetIntegrationTasksAdmin `get_integration_tasks_admin`	Get all the integration tasks, requires admin scope
GetUsersV2 `get_users_v2`	List users
PostGroupV2 `post_group_v2`	Create group
UpdateDefaultGroup `update_default_group`	Update default group
UpdateGroup `update_group`	Update group

ExecuteFunctionDataCount

A selected list of queryLanguage count queries.

POST /application-security/aggregates/function-data/count/v1

Scope ASPM Read Only: WRITE Consumes · Produces application/json

PEP 8 execute_function_data_count

Parameters

Name	Type	Data type	Description
aws_lambda_arn	query	string	AWS Lambda ARN. Required for `aws` cloud provider.
azure_function_app_name	query	string	Azure Function App name. Required for `azure` cloud provider.
azure_site_resource_group	query	string	Azure site resource group. Required for `azure` cloud provider.
azure_site_subscription_id	query	string	Azure site subscription ID. Required for `azure` cloud provider.
cloud_provider	query	string or list of strings	Cloud provider ID. Allowed values: `aws`, `azure` and `gcp`. Required.
gcp_cloud_function_url	query	string	GCP Cloud Function URL. Required for `gcp` cloud provider.
parameters	query	dictionary	Full query string parameters payload in JSON format.
query_name	query	string	Query name. Required.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_function_data_count(aws_lambda_arn="string",
                                              azure_function_app_name="string",
                                              azure_site_resource_group="string",
                                              azure_site_subscription_id="string",
                                              cloud_provider="string",
                                              gcp_cloud_function_url="string",
                                              query_name="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionDataCount(aws_lambda_arn="string",
                                           azure_function_app_name="string",
                                           azure_site_resource_group="string",
                                           azure_site_subscription_id="string",
                                           cloud_provider="string",
                                           gcp_cloud_function_url="string",
                                           query_name="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionDataCount",
                          query_name="string",
                          cloud_provider="string",
                          aws_lambda_arn="string",
                          gcp_cloud_function_url="string",
                          azure_site_subscription_id="string",
                          azure_site_resource_group="string",
                          azure_function_app_name="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  awsLambdaArn := "string"
  gcpCloudFunctionURL := "string"
  azureSiteSubscriptionID := "string"
  azureSiteResourceGroup := "string"
  azureFunctionAppName := "string"

  response, err := client.Aspm.ExecuteFunctionDataCount(
    &a_s_p_m.ExecuteFunctionDataCountParams{
      QueryName: "string",
      CloudProvider: "string",
      AwsLambdaArn: &awsLambdaArn,
      GcpCloudFunctionURL: &gcpCloudFunctionURL,
      AzureSiteSubscriptionID: &azureSiteSubscriptionID,
      AzureSiteResourceGroup: &azureSiteResourceGroup,
      AzureFunctionAppName: &azureFunctionAppName,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionDataCount(
  "string",  // queryName
  "string",  // cloudProvider
  "string",  // awsLambdaArn
  "string",  // gcpCloudFunctionUrl
  "string",  // azureSiteSubscriptionId
  "string",  // azureSiteResourceGroup
  "string"  // azureFunctionAppName
);

console.log(response);

use rusty_falcon::apis::aspm_api::execute_function_data_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_function_data_count(
        &falcon.cfg,  // configuration
        "string",  // query_name
        "string",  // cloud_provider
        Some("string"),  // aws_lambda_arn
        Some("string"),  // gcp_cloud_function_url
        Some("string"),  // azure_site_subscription_id
        Some("string"),  // azure_site_resource_group
        Some("string"),  // azure_function_app_name
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_function_data_count('string', 'string')

puts response

ExecuteFunctionsCount

A selected list of queryLanguage count queries.

POST /application-security/aggregates/functions/count/v1

Scope ASPM Read Only: WRITE Consumes · Produces application/json

PEP 8 execute_functions_count

Parameters

Name	Type	Data type	Description
cid	query	string or list of strings	Customer ID. Required for `azure` cloud provider.
cloud_account_id	query	string or list of strings	AWS Cloud Account ID. Required for `aws` cloud provider.
cloud_provider	query	string or list of strings	Cloud provider ID. Allowed values: `aws`, `azure` and `gcp`. Required.
parameters	query	dictionary	Full query string parameters payload in JSON format.
query_name	query	string	Query name. Required.
region	query	string or list of strings	GCP Region. Required for `gcp` cloud provider.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.execute_functions_count(cid=id_list,
                                          cloud_account_id=id_list,
                                          cloud_provider=id_list,
                                          query_name="string",
                                          region=id_list)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.ExecuteFunctionsCount(cid=id_list,
                                        cloud_account_id=id_list,
                                        cloud_provider=id_list,
                                        query_name="string",
                                        region=id_list)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("ExecuteFunctionsCount",
                          query_name="string",
                          cloud_provider=id_list,
                          cloud_account_id=id_list,
                          region=id_list,
                          cid=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionsCount(
    &a_s_p_m.ExecuteFunctionsCountParams{
      QueryName: "string",
      CloudProvider: []string{"ID1", "ID2", "ID3"},
      CloudAccountID: []string{"ID1", "ID2", "ID3"},
      Region: []string{"ID1", "ID2", "ID3"},
      Cid: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionsCount(
  "string",  // queryName
  ["ID1", "ID2", "ID3"],  // cloudProvider
  ["ID1", "ID2", "ID3"],  // cloudAccountId
  ["ID1", "ID2", "ID3"],  // region
  ["ID1", "ID2", "ID3"]  // cid
);

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions_count(
        &falcon.cfg,  // configuration
        "string",  // query_name
        Some(vec!["string".to_string()]),  // cloud_provider
        Some(vec!["string".to_string()]),  // cloud_account_id
        Some(vec!["string".to_string()]),  // region
        Some(vec!["string".to_string()]),  // cid
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions_count('string')

puts response

ExecuteFunctionDataQueryCount

A selected list of queryLanguage count queries.

GET /application-security/aggregates/query-function-data-count/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_function_data_query_count

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_function_data_query_count(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionDataQueryCount(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionDataQueryCount",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionDataQueryCount(
    &a_s_p_m.ExecuteFunctionDataQueryCountParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionDataQueryCount("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_function_data_query_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_function_data_query_count(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_function_data_query_count('string')

puts response

ExecuteFunctionsQueryCount

A selected list of queryLanguage count queries.

GET /application-security/aggregates/query-functions-count/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_functions_query_count

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_functions_query_count(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionsQueryCount(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionsQueryCount",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionsQueryCount(
    &a_s_p_m.ExecuteFunctionsQueryCountParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionsQueryCount("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions_query_count;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions_query_count(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions_query_count('string')

puts response

ExecuteFunctionData

A selected list of queryLanguage queries.

GET /application-security/combined/function-data/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_function_data

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_function_data(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionData(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionData",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionData(
    &a_s_p_m.ExecuteFunctionDataParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionData("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_function_data;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_function_data(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_function_data('string')

puts response

ExecuteFunctionsOvertime

A selected list of queryLanguage overtime queries.

GET /application-security/combined/functions-overtime/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_functions_over_time

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_functions_over_time(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionsOvertime(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionsOvertime",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionsOvertime(
    &a_s_p_m.ExecuteFunctionsOvertimeParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionsOvertime("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions_overtime;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions_overtime(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions_overtime('string')

puts response

ExecuteFunctions

A selected list of queryLanguage services queries.

GET /application-security/combined/functions/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_functions

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_functions(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctions(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctions",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctions(
    &a_s_p_m.ExecuteFunctionsParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctions("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions('string')

puts response

ExecuteFunctionDataQuery

A selected list of queryLanguage queries.

GET /application-security/combined/query-function-data/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_function_data_query

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_function_data_query(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionDataQuery(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionDataQuery",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionDataQuery(
    &a_s_p_m.ExecuteFunctionDataQueryParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionDataQuery("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_function_data_query;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_function_data_query(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_function_data_query('string')

puts response

ExecuteFunctionsQueryOvertime

A selected list of queryLanguage overtime queries.

GET /application-security/combined/query-functions-overtime/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_functions_query_over_time

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_functions_query_over_time(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionsQueryOvertime(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionsQueryOvertime",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionsQueryOvertime(
    &a_s_p_m.ExecuteFunctionsQueryOvertimeParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionsQueryOvertime("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions_query_overtime;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions_query_overtime(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions_query_overtime('string')

puts response

ExecuteFunctionsQuery

A selected list of queryLanguage services queries.

GET /application-security/combined/query-functions/v1

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_functions_query

Parameters

Name	Type	Data type	Description
field	query	string	Query fields.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_functions_query(field="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteFunctionsQuery(field="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ExecuteFunctionsQuery",
                          field="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.ExecuteFunctionsQuery(
    &a_s_p_m.ExecuteFunctionsQueryParams{
      Field: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeFunctionsQuery("string");  // field

console.log(response);

use rusty_falcon::apis::aspm_api::execute_functions_query;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = execute_functions_query(
        &falcon.cfg,  // configuration
        "string",  // field
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.execute_functions_query('string')

puts response

getServiceArtifacts

Retrieve service artifacts.

GET /aspm-api-gateway/api/v1/artifacts

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_service_artifacts

Parameters

Name	Type	Data type	Description
persistent_signature	query	string	Persistent signature.
optional_time	query	string	Optional time.
revision_id	query	string	Revision ID.
limit	query	integer	Upper bound for records returned.
offset	query	integer	Starting position of records returned.
order_by	query	string or list of strings	Sort order field(s).
direction	query	string	Sort order direction. Allowed values: `asc` or `desc`.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_service_artifacts(persistent_signature="string",
                                        optional_time="string",
                                        revision_id="string",
                                        limit=integer,
                                        offset=integer,
                                        order_by=id_list,
                                        direction="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.getServiceArtifacts(persistent_signature="string",
                                      optional_time="string",
                                      revision_id="string",
                                      limit=integer,
                                      offset=integer,
                                      order_by=id_list,
                                      direction="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("getServiceArtifacts",
                          persistent_signature="string",
                          optional_time=integer,
                          revision_id=integer,
                          limit=integer,
                          offset=integer,
                          order_by=id_list,
                          direction="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  optionalTime := int64(0)
  revisionID := int64(0)
  limit := int64(0)
  offset := int64(0)
  direction := "string"

  response, err := client.Aspm.GetServiceArtifacts(
    &a_s_p_m.GetServiceArtifactsParams{
      PersistentSignature: "string",
      OptionalTime: &optionalTime,
      RevisionID: &revisionID,
      Limit: &limit,
      Offset: &offset,
      OrderBy: []string{"ID1", "ID2", "ID3"},
      Direction: &direction,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getServiceArtifacts(
  "string",  // persistentSignature
  integer,  // optionalTime
  integer,  // revisionId
  integer,  // limit
  integer,  // offset
  ["ID1", "ID2", "ID3"],  // orderBy
  "string"  // direction
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_service_artifacts;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_service_artifacts(
        &falcon.cfg,  // configuration
        "string",  // persistent_signature
        Some(integer),  // optional_time
        Some(integer),  // revision_id
        Some(integer),  // limit
        Some(integer),  // offset
        Some(vec!["string".to_string()]),  // order_by
        Some("string"),  // direction
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_service_artifacts('string')

puts response

UpsertBusinessApplications

Create or Update Business Applications

PUT /aspm-api-gateway/api/v1/business_applications

Scope ASPM Analyst: WRITE Consumes · Produces application/json

PEP 8 update_business_applications

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
name	body	string	Application name.
persistent_signature	body	string or list of strings	Signature to persist.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.update_business_applications(name="string",
                                               persistent_signatures=["string"])
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.UpsertBusinessApplications(name="string",
                                             persistent_signatures=["string"])
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "name": "string",
    "persistent_signatures": ["string"]
}

response = falcon.command("UpsertBusinessApplications", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  name := "string"

  response, err := client.Aspm.UpsertBusinessApplications(
    &a_s_p_m.UpsertBusinessApplicationsParams{
      Body: &models.TypesUpsertBusinessApplicationRequest{
        Name: &name,
        Persistentsignatures: []string{"string"},
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.upsertBusinessApplications(
  {
    name: "string",
    persistentSignatures: []
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::upsert_business_applications;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesUpsertBusinessApplicationRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesUpsertBusinessApplicationRequest {
        name: Some("string".to_string()),
        persistent_signatures: vec!["string".to_string()],
        ..Default::default()
    };

    let response = upsert_business_applications(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesUpsertBusinessApplicationRequest.new(
  name: 'string',
  persistentSignatures: []
)

response = api.upsert_business_applications(body)

puts response

GetCloudSecurityIntegrationState

Get Cloud Security integration state.

GET /aspm-api-gateway/api/v1/cloud_security_config

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 get_cloud_security_integration_state

No keywords or arguments accepted.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_cloud_security_integration_state()
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetCloudSecurityIntegrationState()
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetCloudSecurityIntegrationState")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.GetCloudSecurityIntegrationState(
    &a_s_p_m.GetCloudSecurityIntegrationStateParams{
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getCloudSecurityIntegrationState();

console.log(response);

use rusty_falcon::apis::aspm_api::get_cloud_security_integration_state;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_cloud_security_integration_state(&falcon.cfg).await.expect("API call failed");  // configuration

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_cloud_security_integration_state

puts response

SetCloudSecurityIntegrationState

Set Cloud Security integration state.

POST /aspm-api-gateway/api/v1/cloud_security_config

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 set_cloud_security_integration_state

Parameters

Name	Type	Data type	Description
body	body	string	Full body payload as a JSON formatted dictionary.
is_enabled	body	boolean	Flag indicating if the state should be enabled.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.set_cloud_security_integration_state(is_enabled=boolean)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.SetCloudSecurityIntegrationState(is_enabled=boolean)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "is_enabled": boolean
}

response = falcon.command("SetCloudSecurityIntegrationState", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  isEnabled := boolean

  response, err := client.Aspm.SetCloudSecurityIntegrationState(
    &a_s_p_m.SetCloudSecurityIntegrationStateParams{
      Body: &models.TypesSetCloudSecurityIntegrationStateRequest{
        Isenabled: &isEnabled,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.setCloudSecurityIntegrationState(
  {
    isEnabled: boolean
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::set_cloud_security_integration_state;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesSetCloudSecurityIntegrationStateRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesSetCloudSecurityIntegrationStateRequest {
        is_enabled: Some(boolean),
        ..Default::default()
    };

    let response = set_cloud_security_integration_state(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesSetCloudSecurityIntegrationStateRequest.new(
  isEnabled: boolean
)

response = api.set_cloud_security_integration_state(body)

puts response

GetExecutorNodes

Get all the relay nodes

GET /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 get_executor_nodes

Parameters

Name	Type	Data type	Description
direction	query	string	Sort order direction. Allowed values: `asc` or `desc`.
executor_node_ids	query	string or list of strings	Executor node IDs.
executor_node_names	query	string or list of strings	Executor node names.
executor_node_states	query	string or list of strings	Executor node states.
executor_node_types	query	string or list of strings	Executor node types.
node_type	query	string	Relay node type.
integration_type	query	string	Integration type.
limit	query	integer	Maximum number of records to return.
offset	query	integer	Starting position from which to return records.
order_by	query	string	Field to use for sorting results. Allowed values: `name`, `id`, `state` and `type`.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_executor_nodes(direction="string",
                                     executor_node_ids=id_list,
                                     executor_node_names=id_list,
                                     executor_node_states=id_list,
                                     executor_node_types=id_list,
                                     node_type="string",
                                     integration_type="string",
                                     limit=integer,
                                     offset=integer,
                                     order_by="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetExecutorNodes(direction="string",
                                   executor_node_ids=id_list,
                                   executor_node_names=id_list,
                                   executor_node_states=id_list,
                                   executor_node_types=id_list,
                                   node_type="string",
                                   integration_type="string",
                                   limit=integer,
                                   offset=integer,
                                   order_by="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetExecutorNodes",
                          node_type="string",
                          integration_type=integer,
                          offset=integer,
                          limit=integer,
                          order_by="string",
                          direction="string",
                          executor_node_ids=id_list,
                          executor_node_names=id_list,
                          executor_node_states=id_list,
                          executor_node_types=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationType := int64(0)
  offset := int64(0)
  limit := int64(0)
  orderBy := "string"
  direction := "string"

  response, err := client.Aspm.GetExecutorNodes(
    &a_s_p_m.GetExecutorNodesParams{
      NodeType: "string",
      IntegrationType: &integrationType,
      Offset: &offset,
      Limit: &limit,
      OrderBy: &orderBy,
      Direction: &direction,
      ExecutorNodeIds: []string{"ID1", "ID2", "ID3"},
      ExecutorNodeNames: []string{"ID1", "ID2", "ID3"},
      ExecutorNodeStates: []integer{0},
      ExecutorNodeTypes: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getExecutorNodes(
  "string",  // nodeType
  integer,  // integrationType
  integer,  // offset
  integer,  // limit
  "string",  // orderBy
  "string",  // direction
  ["ID1", "ID2", "ID3"],  // executorNodeIds
  ["ID1", "ID2", "ID3"],  // executorNodeNames
  integer,  // executorNodeStates
  ["ID1", "ID2", "ID3"]  // executorNodeTypes
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_executor_nodes;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_executor_nodes(
        &falcon.cfg,  // configuration
        "string",  // node_type
        Some(integer),  // integration_type
        Some(integer),  // offset
        Some(integer),  // limit
        Some("string"),  // order_by
        Some("string"),  // direction
        Some(vec!["string".to_string()]),  // executor_node_ids
        Some(vec!["string".to_string()]),  // executor_node_names
        Some(vec![]),  // executor_node_states
        Some(vec!["string".to_string()]),  // executor_node_types
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_executor_nodes('string')

puts response

UpdateExecutorNode

Update an existing relay node

PUT /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 update_executor_node

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
additional_header	body	string	Additional headers.
current_aws_arn	body	string	AWS ARN.
dashboard_url	body	string	Dashboard URL address.
last_health_check	body	integer	Last health check.
name	body	string	Node name.
node_type	body	string	Node type.
password	body	string	Password.
pod_settings	body	dictionary	Pod settings.
proxy_address	body	string	Proxy server address.
type	body	string	Type.
use_jobs	body	boolean	Flag indicating if jobs should be used.
username	body	string	Username.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

pod_settings = {
    "image_address": "string",
    "image_pull_secrets": ["string"],
    "pod_labels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "state": integer,
    "state_last_updated": integer,
    "state_reason": integer
}

response = falcon.update_executor_node(additional_header="string",
                                       current_aws_arn="string",
                                       dashboard_url="string",
                                       id="string",
                                       last_health_check=integer,
                                       name="string",
                                       node_type="string",
                                       password="string",
                                       pod_settings=pod_settings,
                                       proxy_address="string",
                                       status=status,
                                       type="string",
                                       use_jobs=boolean,
                                       username="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

pod_settings = {
    "image_address": "string",
    "image_pull_secrets": ["string"],
    "pod_labels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "state": integer,
    "state_last_updated": integer,
    "state_reason": integer
}

response = falcon.UpdateExecutorNode(additional_header="string",
                                     current_aws_arn="string",
                                     dashboard_url="string",
                                     id="string",
                                     last_health_check=integer,
                                     name="string",
                                     node_type="string",
                                     password="string",
                                     pod_settings=pod_settings,
                                     proxy_address="string",
                                     status=status,
                                     type="string",
                                     use_jobs=boolean,
                                     username="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": integer,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
        "image_address": "string",
        "image_pull_secrets": ["string"],
        "pod_labels": [
            {
                "key": "string",
                "value": "string"
            }
        ]
    },
    "proxy_address": "string",
    "status": {
        "state": integer,
        "state_last_updated": integer,
        "state_reason": integer
    },
    "type": "string",
    "use_jobs": boolean,
    "username": "string"
}

response = falcon.command("UpdateExecutorNode", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  additional_header := "string"
  current_aws_arn := "string"
  dashboard_url := "string"
  id := "string"
  last_health_check := integer
  name := "string"
  node_type := "string"
  password := "string"
  proxy_address := "string"
  type := "string"
  useJobs := boolean
  username := "string"

  response, err := client.Aspm.UpdateExecutorNode(
    &a_s_p_m.UpdateExecutorNodeParams{
      Body: &models.TypesExecutorNode{
        AdditionalHeader: &additional_header,
        CurrentAwsArn: &current_aws_arn,
        DashboardUrl: &dashboard_url,
        ID: &id,
        LastHealthCheck: &last_health_check,
        Name: &name,
        NodeType: &node_type,
        Password: &password,
        PodSettings: &struct{}{},
        ProxyAddress: &proxy_address,
        Status: &struct{}{},
        Type: &type,
        Usejobs: &useJobs,
        Username: &username,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.updateExecutorNode(
  {
    additionalHeader: "string",
    currentAwsArn: "string",
    dashboardUrl: "string",
    id: "string",
    lastHealthCheck: integer,
    name: "string",
    nodeType: "string",
    password: "string",
    podSettings: {
      imageAddress: "string",
      imagePullSecrets: [],
      podLabels: [{
          key: "string",
          value: "string"
        }]
    },
    proxyAddress: "string",
    status: {
      State: integer,
      StateLastUpdated: integer,
      StateReason: integer
    },
    type: "string",
    useJobs: boolean,
    username: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::update_executor_node;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesExecutorNode;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesExecutorNode {
        ..Default::default()
    };

    let response = update_executor_node(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesExecutorNode.new(
  additional_header: 'string',
  current_aws_arn: 'string',
  dashboard_url: 'string',
  id: 'string',
  last_health_check: integer,
  name: 'string',
  node_type: 'string',
  password: 'string',
  pod_settings: {
    imageAddress: 'string',
    imagePullSecrets: [],
    podLabels: [{
        key: 'string',
        value: 'string'
      }]
  },
  proxy_address: 'string',
  status: {
    State: integer,
    StateLastUpdated: integer,
    StateReason: integer
  },
  type: 'string',
  useJobs: boolean,
  username: 'string'
)

response = api.update_executor_node(body)

puts response

CreateExecutorNode

Create a new relay node

POST /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 create_executor_node

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
additional_header	body	string	Additional headers.
current_aws_arn	body	string	AWS ARN.
dashboard_url	body	string	Dashboard URL address.
id	body	integer	Node ID.
last_health_check	body	integer	Last health check.
name	body	string	Node name.
node_type	body	string	Node type.
password	body	string	Password.
pod_settings	body	dictionary	Pod settings.
proxy_address	body	string	Proxy server address.
type	body	string	Type.
use_jobs	body	boolean	Flag indicating if jobs should be used.
username	body	string	Username.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

pod_settings = {
    "image_address": "string",
    "image_pull_secrets": ["string"],
    "pod_labels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "state": integer,
    "state_last_updated": integer,
    "state_reason": integer
}

response = falcon.create_executor_node(additional_header="string",
                                       current_aws_arn="string",
                                       dashboard_url="string",
                                       id="string",
                                       last_health_check=integer,
                                       name="string",
                                       node_type="string",
                                       password="string",
                                       pod_settings=pod_settings,
                                       proxy_address="string",
                                       status=status,
                                       type="string",
                                       use_jobs=boolean,
                                       username="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

pod_settings = {
    "image_address": "string",
    "image_pull_secrets": ["string"],
    "pod_labels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "state": integer,
    "state_last_updated": integer,
    "state_reason": integer
}

response = falcon.CreateExecutorNode(additional_header="string",
                                     current_aws_arn="string",
                                     dashboard_url="string",
                                     id="string",
                                     last_health_check=integer,
                                     name="string",
                                     node_type="string",
                                     password="string",
                                     pod_settings=pod_settings,
                                     proxy_address="string",
                                     status=status,
                                     type="string",
                                     use_jobs=boolean,
                                     username="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": integer,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
        "image_address": "string",
        "image_pull_secrets": ["string"],
        "pod_labels": [
            {
                "key": "string",
                "value": "string"
            }
        ]
    },
    "proxy_address": "string",
    "status": {
        "state": integer,
        "state_last_updated": integer,
        "state_reason": integer
    },
    "type": "string",
    "use_jobs": boolean,
    "username": "string"
}

response = falcon.command("CreateExecutorNode", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  additional_header := "string"
  current_aws_arn := "string"
  dashboard_url := "string"
  id := "string"
  last_health_check := integer
  name := "string"
  node_type := "string"
  password := "string"
  proxy_address := "string"
  type := "string"
  useJobs := boolean
  username := "string"

  response, err := client.Aspm.CreateExecutorNode(
    &a_s_p_m.CreateExecutorNodeParams{
      Body: &models.TypesExecutorNode{
        AdditionalHeader: &additional_header,
        CurrentAwsArn: &current_aws_arn,
        DashboardUrl: &dashboard_url,
        ID: &id,
        LastHealthCheck: &last_health_check,
        Name: &name,
        NodeType: &node_type,
        Password: &password,
        PodSettings: &struct{}{},
        ProxyAddress: &proxy_address,
        Status: &struct{}{},
        Type: &type,
        Usejobs: &useJobs,
        Username: &username,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.createExecutorNode(
  {
    additionalHeader: "string",
    currentAwsArn: "string",
    dashboardUrl: "string",
    id: "string",
    lastHealthCheck: integer,
    name: "string",
    nodeType: "string",
    password: "string",
    podSettings: {
      imageAddress: "string",
      imagePullSecrets: [],
      podLabels: [{
          key: "string",
          value: "string"
        }]
    },
    proxyAddress: "string",
    status: {
      State: integer,
      StateLastUpdated: integer,
      StateReason: integer
    },
    type: "string",
    useJobs: boolean,
    username: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::create_executor_node;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesExecutorNode;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesExecutorNode {
        ..Default::default()
    };

    let response = create_executor_node(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesExecutorNode.new(
  additional_header: 'string',
  current_aws_arn: 'string',
  dashboard_url: 'string',
  id: 'string',
  last_health_check: integer,
  name: 'string',
  node_type: 'string',
  password: 'string',
  pod_settings: {
    imageAddress: 'string',
    imagePullSecrets: [],
    podLabels: [{
        key: 'string',
        value: 'string'
      }]
  },
  proxy_address: 'string',
  status: {
    State: integer,
    StateLastUpdated: integer,
    StateReason: integer
  },
  type: 'string',
  useJobs: boolean,
  username: 'string'
)

response = api.create_executor_node(body)

puts response

GetExecutorNodesMetadata

Get metadata about all executor nodes.

GET /aspm-api-gateway/api/v1/executor_nodes/metadata

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_executor_nodes_metadata

Parameters

Name	Type	Data type	Description
executor_node_ids	query	string or list of strings	Executor node IDs.
executor_node_names	query	string or list of strings	Executor node names.
executor_node_states	query	integer or list of integers	Executor node states.
executor_node_types	query	string or list of strings	Executor node types.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_executor_nodes_metadata(executor_node_ids=id_list,
                                              executor_node_names=id_list,
                                              executor_node_states=integer,
                                              executor_node_types=id_list)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetExecutorNodesMetadata(executor_node_ids=id_list,
                                           executor_node_names=id_list,
                                           executor_node_states=integer,
                                           executor_node_types=id_list)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetExecutorNodesMetadata",
                          executor_node_ids=id_list,
                          executor_node_names=id_list,
                          executor_node_states=id_list,
                          executor_node_types=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.GetExecutorNodesMetadata(
    &a_s_p_m.GetExecutorNodesMetadataParams{
      ExecutorNodeIds: []string{"ID1", "ID2", "ID3"},
      ExecutorNodeNames: []string{"ID1", "ID2", "ID3"},
      ExecutorNodeStates: []integer{0},
      ExecutorNodeTypes: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getExecutorNodesMetadata(
  ["ID1", "ID2", "ID3"],  // executorNodeIds
  ["ID1", "ID2", "ID3"],  // executorNodeNames
  integer,  // executorNodeStates
  ["ID1", "ID2", "ID3"]  // executorNodeTypes
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_executor_nodes_metadata;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_executor_nodes_metadata(
        &falcon.cfg,  // configuration
        Some(vec!["string".to_string()]),  // executor_node_ids
        Some(vec!["string".to_string()]),  // executor_node_names
        Some(vec![]),  // executor_node_states
        Some(vec!["string".to_string()]),  // executor_node_types
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_executor_nodes_metadata(executor_node_ids: ['ID1', 'ID2', 'ID3'],
                                           executor_node_names: ['ID1', 'ID2', 'ID3'],
                                           executor_node_states: ['ID1', 'ID2', 'ID3'],
                                           executor_node_types: ['ID1', 'ID2', 'ID3'])

puts response

DeleteExecutorNode

Delete a relay node

DELETE /aspm-api-gateway/api/v1/executor_nodes/{ID}

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 delete_node

Parameters

Name	Type	Data type	Description
id	path	integer	Executor node ID.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.delete_node(id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.DeleteExecutorNode(id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("DeleteExecutorNode",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.DeleteExecutorNode(
    &a_s_p_m.DeleteExecutorNodeParams{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.deleteExecutorNode(integer);  // iD

console.log(response);

use rusty_falcon::apis::aspm_api::delete_executor_node;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = delete_executor_node(
        &falcon.cfg,  // configuration
        integer,  // id
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.delete_executor_node('string')

puts response

RetrieveRelayInstances

Retrieve the relay instances in CSV format.

GET /aspm-api-gateway/api/v1/executor_nodes/{ID}/instances/csv

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 retrieve_relay_instances

Parameters

Name	Type	Data type	Description
additional_header	body	string	Additional header to provide.
body	body	string	Full body payload as a JSON formatted dictionary.
current_aws_arn	body	string	Current AWS ARN.
dashboard_url	body	string	URL for the related dashboard.
id	path	integer	ID of the node to retrieve.
last_health_check	body	integer	Last health check.
name	body	string	Name.
node_type	body	string	Node type.
pod_settings	body	dictionary	Related pod settings.
proxy_address	body	string	Address of the proxy.
status	body	dictionary	Current status.
type	body	string	Relay type.
use_jobs	body	boolean	Flag indicating if jobs should be used.
username	body	string	Account username.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.retrieve_relay_instances(additional_header="string",
                                           current_aws_arn="string",
                                           dashboard_url="string",
                                           id=integer,
                                           last_health_check=integer,
                                           name="string",
                                           node_type="string",
                                           pod_settings={},
                                           proxy_address="string",
                                           status={},
                                           type="string",
                                           use_jobs=boolean,
                                           username="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.RetrieveRelayInstances(additional_header="string",
                                         current_aws_arn="string",
                                         dashboard_url="string",
                                         id=integer,
                                         last_health_check=integer,
                                         name="string",
                                         node_type="string",
                                         pod_settings={},
                                         proxy_address="string",
                                         status={},
                                         type="string",
                                         use_jobs=boolean,
                                         username="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": integer,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
        "image_address": "string",
        "image_pull_secrets": ["string"],
        "pod_labels": [
            {
                "key": "string",
                "value": "string"
            }
        ]
    },
    "proxy_address": "string",
    "status": {
        "state": integer,
        "state_last_updated": integer,
        "state_reason": integer
    },
    "type": "string",
    "use_jobs": boolean,
    "username": "string"
}

response = falcon.command("RetrieveRelayInstances",
                          id=integer,
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  additional_header := "string"
  current_aws_arn := "string"
  dashboard_url := "string"
  id := "string"
  last_health_check := integer
  name := "string"
  node_type := "string"
  password := "string"
  proxy_address := "string"
  type := "string"
  useJobs := boolean
  username := "string"

  response, err := client.Aspm.GetExecutorNodesID09InstancesCsv(
    &a_s_p_m.GetExecutorNodesID09InstancesCsvParams{
      Body: &models.TypesExecutorNode{
        AdditionalHeader: &additional_header,
        CurrentAwsArn: &current_aws_arn,
        DashboardUrl: &dashboard_url,
        ID: &id,
        LastHealthCheck: &last_health_check,
        Name: &name,
        NodeType: &node_type,
        Password: &password,
        PodSettings: &struct{}{},
        ProxyAddress: &proxy_address,
        Status: &struct{}{},
        Type: &type,
        Usejobs: &useJobs,
        Username: &username,
      },
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getExecutorNodesID09InstancesCsv(
  integer,  // iD
  {  // body
      additionalHeader: "string",
      currentAwsArn: "string",
      dashboardUrl: "string",
      id: "string",
      lastHealthCheck: integer,
      name: "string",
      nodeType: "string",
      password: "string",
      podSettings: {
        imageAddress: "string",
        imagePullSecrets: [],
        podLabels: [{
            key: "string",
            value: "string"
          }]
      },
      proxyAddress: "string",
      status: {
        State: integer,
        StateLastUpdated: integer,
        StateReason: integer
      },
      type: "string",
      useJobs: boolean,
      username: "string"
  }
);

console.log(response);

GetIntegrationTasks

Get all the integration tasks

GET /aspm-api-gateway/api/v1/integration_tasks

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_integration_tasks

Parameters

Name	Type	Data type	Description
integration_task_type	query	string	Integration task type.
category	query	string	Integration task category.
offset	query	integer	Starting position from which to return records.
limit	query	integer	Maximum number of records to return.
order_by	query	string	Field to use for sorting results.
direction	query	string	Sort order direction. Allowed values: `asc` or `desc`.
integration_task_types	query	integer	Integration task types.
ids	query	integer	Integration task ID to retrieve.
names	query	string	Integration task name.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_integration_tasks(integration_task_type=integer,
                                        category="string",
                                        offset=integer,
                                        limit=integer,
                                        order_by="string",
                                        direction="string",
                                        integration_task_types=integer,
                                        ids=id_list,
                                        names="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetIntegrationTasks(integration_task_type=integer,
                                      category="string",
                                      offset=integer,
                                      limit=integer,
                                      order_by="string",
                                      direction="string",
                                      integration_task_types=integer,
                                      ids=id_list,
                                      names="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetIntegrationTasks",
                          integration_task_type=integer,
                          category="string",
                          offset=integer,
                          limit=integer,
                          order_by="string",
                          direction="string",
                          integration_task_types=integer,
                          ids=integer,
                          names="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationTaskType := int64(0)
  category := "string"
  offset := int64(0)
  limit := int64(0)
  orderBy := "string"
  direction := "string"
  integrationTaskTypes := int64(0)
  ids := int64(0)
  names := "string"

  response, err := client.Aspm.GetIntegrationTasks(
    &a_s_p_m.GetIntegrationTasksParams{
      IntegrationTaskType: &integrationTaskType,
      Category: &category,
      Offset: &offset,
      Limit: &limit,
      OrderBy: &orderBy,
      Direction: &direction,
      IntegrationTaskTypes: &integrationTaskTypes,
      Ids: &ids,
      Names: &names,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationTasks(
  integer,  // integrationTaskType
  "string",  // category
  integer,  // offset
  integer,  // limit
  integer,  // orderBy
  integer,  // direction
  integer,  // integrationTaskTypes
  integer,  // ids
  "string"  // names
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integration_tasks;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integration_tasks(
        &falcon.cfg,  // configuration
        Some(integer),  // integration_task_type
        Some("string"),  // category
        Some(integer),  // offset
        Some(integer),  // limit
        Some("string"),  // order_by
        Some("string"),  // direction
        Some(integer),  // integration_task_types
        Some(integer),  // ids
        Some("string"),  // names
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integration_tasks(integration_task_type: integer,
                                     category: 'string',
                                     offset: integer,
                                     limit: integer,
                                     orderBy: 'string',
                                     direction: 'string',
                                     integration_task_types: integer,
                                     ids: integer,
                                     names: 'string')

puts response

CreateIntegrationTask

Create new integration task.

POST /aspm-api-gateway/api/v1/integration_tasks

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 create_integration_task

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
access_token	body	string	Access token.
task_id	body	integer	Task ID.
data	body	string	Task data content.
override	body	boolean	Flag indicating if this task should override other task values.
scheduled	body	boolean	Flag indicating if this task is scheduled.
id	path	dictionary	ID of the integration task to execute.
integration_task	query	integration	Full integration task detail.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

integration_task = {
    "access_token": "string",
    "additional_header": "string",
    "business_application": "string",
    "data": "string",
    "enabled": boolean,
    "id": "string",
    "integration": {
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration_type": {},
        "name": "string",
        "node": {},
        "type": {},
        "update_time": integer
    },
    "integration_task_type": {
        "category": "string",
        "display_name": "string",
        "enabled": boolean,
        "id": integer,
        "name": "string",
        "required_integration_types": ["string"]
    },
    "latest_task_run": {
        "create_time": "string",
        "events": ["string"],
        "id": "string",
        "latest_event": {},
        "metadata": {},
        "progress": integer,
        "scheduled": boolean,
        "trace_uuid": "string"
    },
    "name": "string",
    "next_run": {
        "nanos": integer,
        "seconds": integer
    },
    "progress": integer,
    "schedule": {
        "every": integer,
        "every_unit": integer,
        "hour": integer,
        "minute": integer,
        "start_time_timezone_offset_minutes": integer,
        "start_time": {},
        "timezone": integer,
        "weekdays": ["string"]
    },
    "schedule_every_unit_display_name": "string",
    "trigger": "string",
    "type": {
        "category": "string",
        "display_name": "string",
        "enabled": boolean,
        "id": integer,
        "name": "string",
        "required_integration_types": ["string"]
    }
}

response = falcon.create_integration_task(integration_task=integration_task)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

integration_task = {
    "access_token": "string",
    "additional_header": "string",
    "business_application": "string",
    "data": "string",
    "enabled": boolean,
    "id": "string",
    "integration": {
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration_type": {},
        "name": "string",
        "node": {},
        "type": {},
        "update_time": integer
    },
    "integration_task_type": {
        "category": "string",
        "display_name": "string",
        "enabled": boolean,
        "id": integer,
        "name": "string",
        "required_integration_types": ["string"]
    },
    "latest_task_run": {
        "create_time": "string",
        "events": ["string"],
        "id": "string",
        "latest_event": {},
        "metadata": {},
        "progress": integer,
        "scheduled": boolean,
        "trace_uuid": "string"
    },
    "name": "string",
    "next_run": {
        "nanos": integer,
        "seconds": integer
    },
    "progress": integer,
    "schedule": {
        "every": integer,
        "every_unit": integer,
        "hour": integer,
        "minute": integer,
        "start_time_timezone_offset_minutes": integer,
        "start_time": {},
        "timezone": integer,
        "weekdays": ["string"]
    },
    "schedule_every_unit_display_name": "string",
    "trigger": "string",
    "type": {
        "category": "string",
        "display_name": "string",
        "enabled": boolean,
        "id": integer,
        "name": "string",
        "required_integration_types": ["string"]
    }
}

response = falcon.CreateIntegrationTask(integration_task=integration_task)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "integration_task": {
        "access_token": "string",
        "additional_header": "string",
        "business_application": "string",
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration": {
            "data": "string",
            "enabled": boolean,
            "id": "string",
            "integration_type": {},
            "name": "string",
            "node": {},
            "type": {},
            "update_time": integer
        },
        "integration_task_type": {
            "category": "string",
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string",
            "required_integration_types": ["string"]
        },
        "latest_task_run": {
            "create_time": "string",
            "events": ["string"],
            "id": "string",
            "latest_event": {},
            "metadata": {},
            "progress": integer,
            "scheduled": boolean,
            "trace_uuid": "string"
        },
        "name": "string",
        "next_run": {
            "nanos": integer,
            "seconds": integer
        },
        "progress": integer,
        "schedule": {
            "every": integer,
            "every_unit": integer,
            "hour": integer,
            "minute": integer,
            "start_time_timezone_offset_minutes": integer,
            "start_time": {},
            "timezone": integer,
            "weekdays": ["string"]
        },
        "schedule_every_unit_display_name": "string",
        "trigger": "string",
        "type": {
            "category": "string",
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string",
            "required_integration_types": ["string"]
        }
    }
}

response = falcon.command("CreateIntegrationTask", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.CreateIntegrationTask(
    &a_s_p_m.CreateIntegrationTaskParams{
      Body: &models.TypesCreateIntegrationTaskRequest{
        IntegrationTask: &struct{}{},
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.createIntegrationTask(
  {
    integrationTask: {
      accessToken: "string",
      additionalHeader: "string",
      businessApplication: "string",
      data: "string",
      enabled: boolean,
      id: "string",
      integration: {
        data: "string",
        enabled: boolean,
        id: "string",
        integrationType: {},
        name: "string",
        node: {},
        type: {},
        updateTime: integer
      },
      integrationTaskType: {
        category: "string",
        displayName: "string",
        enabled: boolean,
        id: integer,
        name: "string",
        requiredIntegrationTypes: []
      },
      latestTaskRun: {
        createTime: "string",
        events: [],
        id: "string",
        latestEvent: {},
        metadata: {},
        progress: integer,
        scheduled: boolean,
        traceUuid: "string"
      },
      name: "string",
      nextRun: {
        nanos: integer,
        seconds: integer
      },
      progress: integer,
      schedule: {
        every: integer,
        everyUnit: integer,
        hour: integer,
        minute: integer,
        startTimeTimezoneOffsetMinutes: integer,
        startTime: {},
        timezone: integer,
        weekdays: []
      },
      scheduleEveryUnitDisplayName: "string",
      trigger: "string",
      type: {
        category: "string",
        displayName: "string",
        enabled: boolean,
        id: integer,
        name: "string",
        requiredIntegrationTypes: []
      }
    }
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::create_integration_task;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesCreateIntegrationTaskRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesCreateIntegrationTaskRequest {
        ..Default::default()
    };

    let response = create_integration_task(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesCreateIntegrationTaskRequest.new(
  integration_task: {
    accessToken: 'string',
    additionalHeader: 'string',
    businessApplication: 'string',
    data: 'string',
    enabled: boolean,
    id: 'string',
    integration: {
      data: 'string',
      enabled: boolean,
      id: 'string',
      integration_type: {},
      name: 'string',
      node: {},
      type: {},
      update_time: integer
    },
    integrationTaskType: {
      category: 'string',
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string',
      required_integration_types: []
    },
    latestTaskRun: {
      createTime: 'string',
      events: [],
      id: 'string',
      latestEvent: {},
      metadata: {},
      progress: integer,
      scheduled: boolean,
      traceUuid: 'string'
    },
    name: 'string',
    nextRun: {
      nanos: integer,
      seconds: integer
    },
    progress: integer,
    schedule: {
      every: integer,
      every_unit: integer,
      hour: integer,
      minute: integer,
      startTimeTimezoneOffsetMinutes: integer,
      start_time: {},
      timezone: integer,
      weekdays: []
    },
    scheduleEveryUnitDisplayName: 'string',
    trigger: 'string',
    type: {
      category: 'string',
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string',
      required_integration_types: []
    }
  }
)

response = api.create_integration_task(body)

puts response

GetIntegrationTasksMetadata

Get metadata about all integration tasks.

GET /aspm-api-gateway/api/v1/integration_tasks/metadata

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_integration_tasks_metadata

Parameters

Name	Type	Data type	Description
category	query	string	Category.
integration_task_types	query	integer	Integration task types.
ids	query	integer	Integration task ID to retrieve.
names	query	string	Integration task name.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_integration_tasks_metadata(category="string",
                                                 integration_task_types=integer,
                                                 ids=id_list,
                                                 names="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetIntegrationTasksMetadata(category="string",
                                              integration_task_types=integer,
                                              ids=id_list,
                                              names="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetIntegrationTasksMetadata",
                          category="string",
                          integration_task_types=integer,
                          ids=integer,
                          names="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  category := "string"
  integrationTaskTypes := int64(0)
  ids := int64(0)
  names := "string"

  response, err := client.Aspm.GetIntegrationTasksMetadata(
    &a_s_p_m.GetIntegrationTasksMetadataParams{
      Category: &category,
      IntegrationTaskTypes: &integrationTaskTypes,
      Ids: &ids,
      Names: &names,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationTasksMetadata(
  integer,  // category
  integer,  // integrationTaskTypes
  integer,  // ids
  "string"  // names
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integration_tasks_metadata;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integration_tasks_metadata(
        &falcon.cfg,  // configuration
        Some("string"),  // category
        Some(integer),  // integration_task_types
        Some(integer),  // ids
        Some("string"),  // names
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integration_tasks_metadata(category: 'string',
                                              integration_task_types: integer,
                                              ids: integer,
                                              names: 'string')

puts response

GetIntegrationTasksV2

Get all the integration tasks.

GET /aspm-api-gateway/api/v1/integration_tasks/v2

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 get_integration_tasks_v2

Parameters

Name	Type	Data type	Description
integration_task_type	query	integer	Integration task type.
category	query	string	Category.
offset	query	integer	Starting position from which to return records.
limit	query	integer	Maximum number of records to return.
order_by	query	string	Field to use for sorting results.
direction	query	string	Sort order direction. Allowed values: `asc` or `desc`.
integration_task_types	query	integer	Integration task types.
ids	query	integer	Integration task ID to retrieve.
names	query	string	Integration task name.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_integration_tasks_v2(integration_task_type=integer,
                                           category="string",
                                           offset=integer,
                                           limit=integer,
                                           order_by="string",
                                           direction="string",
                                           integration_task_types=integer,
                                           ids=id_list,
                                           names="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetIntegrationTasksV2(integration_task_type=integer,
                                        category="string",
                                        offset=integer,
                                        limit=integer,
                                        order_by="string",
                                        direction="string",
                                        integration_task_types=integer,
                                        ids=id_list,
                                        names="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetIntegrationTasksV2",
                          integration_task_type=integer,
                          category="string",
                          offset=integer,
                          limit=integer,
                          order_by="string",
                          direction="string",
                          integration_task_types=integer,
                          ids=integer,
                          names="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationTaskType := int64(0)
  category := "string"
  offset := int64(0)
  limit := int64(0)
  orderBy := "string"
  direction := "string"
  integrationTaskTypes := int64(0)
  ids := int64(0)
  names := "string"

  response, err := client.Aspm.GetIntegrationTasksV2(
    &a_s_p_m.GetIntegrationTasksV2Params{
      IntegrationTaskType: &integrationTaskType,
      Category: &category,
      Offset: &offset,
      Limit: &limit,
      OrderBy: &orderBy,
      Direction: &direction,
      IntegrationTaskTypes: &integrationTaskTypes,
      Ids: &ids,
      Names: &names,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationTasksV2(
  integer,  // integrationTaskType
  "string",  // category
  integer,  // offset
  integer,  // limit
  integer,  // orderBy
  integer,  // direction
  integer,  // integrationTaskTypes
  integer,  // ids
  "string"  // names
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integration_tasks_v2;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integration_tasks_v2(
        &falcon.cfg,  // configuration
        Some(integer),  // integration_task_type
        Some("string"),  // category
        Some(integer),  // offset
        Some(integer),  // limit
        Some("string"),  // order_by
        Some("string"),  // direction
        Some(integer),  // integration_task_types
        Some(integer),  // ids
        Some("string"),  // names
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integration_tasks_v2(integration_task_type: integer,
                                        category: 'string',
                                        offset: integer,
                                        limit: integer,
                                        orderBy: 'string',
                                        direction: 'string',
                                        integration_task_types: integer,
                                        ids: integer,
                                        names: 'string')

puts response

UpdateIntegrationTask

Update an existing integration task by its ID

PUT /aspm-api-gateway/api/v1/integration_tasks/{ID}

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 update_integration_task

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
access_token	body	string	Access token.
task_id	body	integer	Task ID.
data	body	string	Task data content.
override	body	boolean	Flag indicating if this task should override other task values.
scheduled	body	boolean	Flag indicating if this task is scheduled.
id	path	dictionary	ID of the integration task to execute.
integration_task	query	integration	Full integration task detail.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.update_integration_task(ID=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.UpdateIntegrationTask(ID=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "integration_task": {
        "access_token": "string",
        "additional_header": "string",
        "business_application": "string",
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration": {
            "data": "string",
            "enabled": boolean,
            "id": "string",
            "integration_type": {},
            "name": "string",
            "node": {},
            "type": {},
            "update_time": integer
        },
        "integration_task_type": {
            "category": "string",
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string",
            "required_integration_types": ["string"]
        },
        "latest_task_run": {
            "create_time": "string",
            "events": ["string"],
            "id": "string",
            "latest_event": {},
            "metadata": {},
            "progress": integer,
            "scheduled": boolean,
            "trace_uuid": "string"
        },
        "name": "string",
        "next_run": {
            "nanos": integer,
            "seconds": integer
        },
        "progress": integer,
        "schedule": {
            "every": integer,
            "every_unit": integer,
            "hour": integer,
            "minute": integer,
            "start_time_timezone_offset_minutes": integer,
            "start_time": {},
            "timezone": integer,
            "weekdays": ["string"]
        },
        "schedule_every_unit_display_name": "string",
        "trigger": "string",
        "type": {
            "category": "string",
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string",
            "required_integration_types": ["string"]
        }
    }
}

response = falcon.command("UpdateIntegrationTask",
                          id=integer,
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.UpdateIntegrationTask(
    &a_s_p_m.UpdateIntegrationTaskParams{
      Body: &models.TypesUpdateIntegrationTaskRequest{
        IntegrationTask: &struct{}{},
      },
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.updateIntegrationTask(
  integer,  // iD
  {  // body
      integrationTask: {
        accessToken: "string",
        additionalHeader: "string",
        businessApplication: "string",
        data: "string",
        enabled: boolean,
        id: "string",
        integration: {
          data: "string",
          enabled: boolean,
          id: "string",
          integrationType: {},
          name: "string",
          node: {},
          type: {},
          updateTime: integer
        },
        integrationTaskType: {
          category: "string",
          displayName: "string",
          enabled: boolean,
          id: integer,
          name: "string",
          requiredIntegrationTypes: []
        },
        latestTaskRun: {
          createTime: "string",
          events: [],
          id: "string",
          latestEvent: {},
          metadata: {},
          progress: integer,
          scheduled: boolean,
          traceUuid: "string"
        },
        name: "string",
        nextRun: {
          nanos: integer,
          seconds: integer
        },
        progress: integer,
        schedule: {
          every: integer,
          everyUnit: integer,
          hour: integer,
          minute: integer,
          startTimeTimezoneOffsetMinutes: integer,
          startTime: {},
          timezone: integer,
          weekdays: []
        },
        scheduleEveryUnitDisplayName: "string",
        trigger: "string",
        type: {
          category: "string",
          displayName: "string",
          enabled: boolean,
          id: integer,
          name: "string",
          requiredIntegrationTypes: []
        }
      }
  }
);

console.log(response);

use rusty_falcon::apis::aspm_api::update_integration_task;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesUpdateIntegrationTaskRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesUpdateIntegrationTaskRequest {
        ..Default::default()
    };

    let response = update_integration_task(
        &falcon.cfg,  // configuration
        integer,  // id
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesUpdateIntegrationTaskRequest.new(
  integration_task: {
    accessToken: 'string',
    additionalHeader: 'string',
    businessApplication: 'string',
    data: 'string',
    enabled: boolean,
    id: 'string',
    integration: {
      data: 'string',
      enabled: boolean,
      id: 'string',
      integration_type: {},
      name: 'string',
      node: {},
      type: {},
      update_time: integer
    },
    integrationTaskType: {
      category: 'string',
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string',
      required_integration_types: []
    },
    latestTaskRun: {
      createTime: 'string',
      events: [],
      id: 'string',
      latestEvent: {},
      metadata: {},
      progress: integer,
      scheduled: boolean,
      traceUuid: 'string'
    },
    name: 'string',
    nextRun: {
      nanos: integer,
      seconds: integer
    },
    progress: integer,
    schedule: {
      every: integer,
      every_unit: integer,
      hour: integer,
      minute: integer,
      startTimeTimezoneOffsetMinutes: integer,
      start_time: {},
      timezone: integer,
      weekdays: []
    },
    scheduleEveryUnitDisplayName: 'string',
    trigger: 'string',
    type: {
      category: 'string',
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string',
      required_integration_types: []
    }
  }
)

response = api.update_integration_task(body, 'string')

puts response

DeleteIntegrationTask

Delete an existing integration task by its ID

DELETE /aspm-api-gateway/api/v1/integration_tasks/{ID}

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 delete_integration_task

Parameters

Name	Type	Data type	Description
id	path	integer	Executor node ID.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.delete_integration_task(ID=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.DeleteIntegrationTask(ID=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("DeleteIntegrationTask",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.DeleteIntegrationTask(
    &a_s_p_m.DeleteIntegrationTaskParams{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.deleteIntegrationTask(integer);  // iD

console.log(response);

use rusty_falcon::apis::aspm_api::delete_integration_task;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = delete_integration_task(
        &falcon.cfg,  // configuration
        integer,  // id
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.delete_integration_task('string')

puts response

RunIntegrationTask

Run an integration task by its ID

POST /aspm-api-gateway/api/v1/integration_tasks/{ID}/run

Scope ASPM Analyst: WRITE Consumes · Produces application/json

PEP 8 run_integration_task

Parameters

Name	Type	Data type	Description
access_token	body	string	Access token.
task_id	body	integer	Task ID.
data	body	string	Task data content.
override	body	boolean	Flag indicating if this task should override other task values.
scheduled	body	boolean	Flag indicating if this task is scheduled.
id	path	dictionary	ID of the integration task to execute.
category	query	string	Integration task category.
body	body	dictionary	Full body payload in JSON format.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.run_integration_task(access_token="string",
                                       category="string",
                                       data="string",
                                       ID=integer,
                                       override=boolean,
                                       scheduled=boolean,
                                       task_id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.RunIntegrationTask(access_token="string",
                                     category="string",
                                     data="string",
                                     ID=integer,
                                     override=boolean,
                                     scheduled=boolean,
                                     task_id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "access_token": "string",
    "category": "string",
    "data": "string",
    "override": boolean,
    "scheduled": boolean,
    "task_id": integer
}

response = falcon.command("RunIntegrationTask",
                          id=integer,
                          category="string",
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  access_token := "string"
  category := "string"
  data := "string"
  override := boolean
  scheduled := boolean
  task_id := integer
  category := "string"

  response, err := client.Aspm.RunIntegrationTask(
    &a_s_p_m.RunIntegrationTaskParams{
      Body: &models.TypesRunIntegrationTaskRequest{
        AccessToken: &access_token,
        Category: &category,
        Data: &data,
        Override: &override,
        Scheduled: &scheduled,
        TaskID: &task_id,
      },
      ID: integer,
      Category: &category,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.runIntegrationTask(
  integer,  // iD
  {  // body
      accessToken: "string",
      category: "string",
      data: "string",
      override: boolean,
      scheduled: boolean,
      taskId: integer
  },
  "string"  // category
);

console.log(response);

use rusty_falcon::apis::aspm_api::run_integration_task;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesRunIntegrationTaskRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesRunIntegrationTaskRequest {
        ..Default::default()
    };

    let response = run_integration_task(
        &falcon.cfg,  // configuration
        integer,  // id
        body,  // body
        Some("string"),  // category
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesRunIntegrationTaskRequest.new(
  access_token: 'string',
  category: 'string',
  data: 'string',
  override: boolean,
  scheduled: boolean,
  task_id: integer
)

response = api.run_integration_task(body, 'string')

puts response

RunIntegrationTaskAdmin

Run an integration task by its ID with admin scope.

POST /aspm-api-gateway/api/v1/integration_tasks/{ID}/run/admin

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 run_integration_task_admin

Parameters

Name	Type	Data type	Description
access_token	body	string	Access token.
task_id	body	integer	Task ID.
data	body	string	Task data content.
override	body	boolean	Flag indicating if this task should override other task values.
scheduled	body	boolean	Flag indicating if this task is scheduled.
id	path	dictionary	ID of the integration task to execute.
category	query	string	Integration task category.
body	body	dictionary	Full body payload in JSON format.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.run_integration_task_admin(ID=integer, category="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.RunIntegrationTaskAdmin(ID=integer, category="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "access_token": "string",
    "category": "string",
    "data": "string",
    "override": boolean,
    "scheduled": boolean,
    "task_id": integer
}

response = falcon.command("RunIntegrationTaskAdmin",
                          id=integer,
                          category="string",
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  access_token := "string"
  category := "string"
  data := "string"
  override := boolean
  scheduled := boolean
  task_id := integer
  category := "string"

  response, err := client.Aspm.RunIntegrationTaskAdmin(
    &a_s_p_m.RunIntegrationTaskAdminParams{
      Body: &models.TypesRunIntegrationTaskRequest{
        AccessToken: &access_token,
        Category: &category,
        Data: &data,
        Override: &override,
        Scheduled: &scheduled,
        TaskID: &task_id,
      },
      ID: integer,
      Category: &category,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.runIntegrationTaskAdmin(
  integer,  // iD
  {  // body
      accessToken: "string",
      category: "string",
      data: "string",
      override: boolean,
      scheduled: boolean,
      taskId: integer
  },
  "string"  // category
);

console.log(response);

use rusty_falcon::apis::aspm_api::run_integration_task_admin;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesRunIntegrationTaskRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesRunIntegrationTaskRequest {
        ..Default::default()
    };

    let response = run_integration_task_admin(
        &falcon.cfg,  // configuration
        integer,  // id
        body,  // body
        Some("string"),  // category
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesRunIntegrationTaskRequest.new(
  access_token: 'string',
  category: 'string',
  data: 'string',
  override: boolean,
  scheduled: boolean,
  task_id: integer
)

response = api.run_integration_task_admin(body, 'string')

puts response

RunIntegrationTaskV2

Run an integration task by its ID

POST /aspm-api-gateway/api/v1/integration_tasks/{ID}/run/v2

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 run_integration_task_v2

Parameters

Name	Type	Data type	Description
access_token	body	string	Access token.
task_id	body	integer	Task ID.
data	body	string	Task data content.
override	body	boolean	Flag indicating if this task should override other task values.
scheduled	body	boolean	Flag indicating if this task is scheduled.
id	path	dictionary	ID of the integration task to execute.
category	query	string	Integration task category.
body	body	dictionary	Full body payload in JSON format.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.run_integration_task_v2(ID=integer, category="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.RunIntegrationTaskV2(ID=integer, category="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "access_token": "string",
    "category": "string",
    "data": "string",
    "override": boolean,
    "scheduled": boolean,
    "task_id": integer
}

response = falcon.command("RunIntegrationTaskV2",
                          id=integer,
                          category="string",
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  access_token := "string"
  category := "string"
  data := "string"
  override := boolean
  scheduled := boolean
  task_id := integer
  category := "string"

  response, err := client.Aspm.RunIntegrationTaskV2(
    &a_s_p_m.RunIntegrationTaskV2Params{
      Body: &models.TypesRunIntegrationTaskRequest{
        AccessToken: &access_token,
        Category: &category,
        Data: &data,
        Override: &override,
        Scheduled: &scheduled,
        TaskID: &task_id,
      },
      ID: integer,
      Category: &category,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.runIntegrationTaskV2(
  integer,  // iD
  {  // body
      accessToken: "string",
      category: "string",
      data: "string",
      override: boolean,
      scheduled: boolean,
      taskId: integer
  },
  "string"  // category
);

console.log(response);

use rusty_falcon::apis::aspm_api::run_integration_task_v2;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesRunIntegrationTaskRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesRunIntegrationTaskRequest {
        ..Default::default()
    };

    let response = run_integration_task_v2(
        &falcon.cfg,  // configuration
        integer,  // id
        body,  // body
        Some("string"),  // category
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesRunIntegrationTaskRequest.new(
  access_token: 'string',
  category: 'string',
  data: 'string',
  override: boolean,
  scheduled: boolean,
  task_id: integer
)

response = api.run_integration_task_v2(body, 'string')

puts response

GetIntegrationTypes

Get all the integration types

GET /aspm-api-gateway/api/v1/integration_types

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 get_integration_types

No keywords or arguments accepted.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_integration_types()
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetIntegrationTypes()
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetIntegrationTypes")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.GetIntegrationTypes(
    &a_s_p_m.GetIntegrationTypesParams{
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationTypes();

console.log(response);

use rusty_falcon::apis::aspm_api::get_integration_types;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integration_types(&falcon.cfg).await.expect("API call failed");  // configuration

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integration_types

puts response

GetIntegrations

Get a list of all the integrations

GET /aspm-api-gateway/api/v1/integrations

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_integrations

Parameters

Name	Type	Data type	Description
integration_type	query	string	Integration type.
category	query	string	Integration category.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_integrations(integration_type="string", category="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetIntegrations(integration_type="string", category="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetIntegrations",
                          integration_type=integer,
                          category="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationType := int64(0)
  category := "string"

  response, err := client.Aspm.GetIntegrations(
    &a_s_p_m.GetIntegrationsParams{
      IntegrationType: &integrationType,
      Category: &category,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrations(
  integer,  // integrationType
  "string"  // category
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integrations;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integrations(
        &falcon.cfg,  // configuration
        Some(integer),  // integration_type
        Some("string"),  // category
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integrations(integration_type: integer, category: 'string')

puts response

CreateIntegration

Create a new integration

POST /aspm-api-gateway/api/v1/integrations

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 create_integration

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
integration	body	dictionary	Integration details in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.create_integration(integration={})
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.CreateIntegration(integration={})
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "integration": {
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration_type": {
            "configured": boolean,
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string"
        },
        "name": "string",
        "node": {
            "additional_header": "string",
            "current_aws_arn": "string",
            "dashboard_url": "string",
            "id": "string",
            "last_health_check": integer,
            "name": "string",
            "node_type": "string",
            "password": "string",
            "pod_settings": {},
            "proxy_address": "string",
            "status": {},
            "type": "string",
            "use_jobs": boolean,
            "username": "string"
        },
        "type": {
            "configured": boolean,
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string"
        },
        "update_time": integer
    }
}

response = falcon.command("CreateIntegration", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.CreateIntegration(
    &a_s_p_m.CreateIntegrationParams{
      Body: &models.TypesCreateIntegrationRequest{
        Integration: &struct{}{},
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.createIntegration(
  {
    integration: {
      data: "string",
      enabled: boolean,
      id: "string",
      integrationType: {
        configured: boolean,
        displayName: "string",
        enabled: boolean,
        id: integer,
        name: "string"
      },
      name: "string",
      node: {
        additionalHeader: "string",
        currentAwsArn: "string",
        dashboardUrl: "string",
        id: "string",
        lastHealthCheck: integer,
        name: "string",
        nodeType: "string",
        password: "string",
        podSettings: {},
        proxyAddress: "string",
        status: {},
        type: "string",
        useJobs: boolean,
        username: "string"
      },
      type: {
        configured: boolean,
        displayName: "string",
        enabled: boolean,
        id: integer,
        name: "string"
      },
      updateTime: integer
    }
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::create_integration;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesCreateIntegrationRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesCreateIntegrationRequest {
        ..Default::default()
    };

    let response = create_integration(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesCreateIntegrationRequest.new(
  integration: {
    data: 'string',
    enabled: boolean,
    id: 'string',
    integration_type: {
      configured: boolean,
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string'
    },
    name: 'string',
    node: {
      additional_header: 'string',
      current_aws_arn: 'string',
      dashboard_url: 'string',
      id: 'string',
      last_health_check: integer,
      name: 'string',
      node_type: 'string',
      password: 'string',
      pod_settings: {},
      proxy_address: 'string',
      status: {},
      type: 'string',
      useJobs: boolean,
      username: 'string'
    },
    type: {
      configured: boolean,
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string'
    },
    update_time: integer
  }
)

response = api.create_integration(body)

puts response

GetIntegrationsV2

Get a list of all the integrations.

GET /aspm-api-gateway/api/v1/integrations/v2

Scope ASPM Admin: READ Consumes · Produces application/json

PEP 8 get_integrations_v2

Parameters

Name	Type	Data type	Description
integration_type	query	integer	Integration type.
category	query	string	Category.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_integrations_v2(integration_type=integer,
                                      category="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetIntegrationsV2(integration_type=integer, category="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetIntegrationsV2",
                          integration_type=integer,
                          category="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationType := int64(0)
  category := "string"

  response, err := client.Aspm.GetIntegrationsV2(
    &a_s_p_m.GetIntegrationsV2Params{
      IntegrationType: &integrationType,
      Category: &category,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationsV2(
  integer,  // integrationType
  "string"  // category
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integrations_v2;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integrations_v2(
        &falcon.cfg,  // configuration
        Some(integer),  // integration_type
        Some("string"),  // category
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integrations_v2(integration_type: integer,
                                   category: 'string')

puts response

UpdateIntegration

Update an existing integration by its ID

PUT /aspm-api-gateway/api/v1/integrations/{ID}

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 update_integration

Parameters

Name	Type	Data type	Description
parameters	query	integer	Integration ID to update.
body	body	dictionary	Full body payload in JSON format.
overwrite_fields	body	list of strings	Fields to be overwritten.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.update_integration(id=integer,
                                     integration={},
                                     overwrite_fields=["string"])
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.UpdateIntegration(id=integer,
                                    integration={},
                                    overwrite_fields=["string"])
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "integration": {
        "data": "string",
        "enabled": boolean,
        "id": "string",
        "integration_type": {
            "configured": boolean,
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string"
        },
        "name": "string",
        "node": {
            "additional_header": "string",
            "current_aws_arn": "string",
            "dashboard_url": "string",
            "id": "string",
            "last_health_check": integer,
            "name": "string",
            "node_type": "string",
            "password": "string",
            "pod_settings": {},
            "proxy_address": "string",
            "status": {},
            "type": "string",
            "use_jobs": boolean,
            "username": "string"
        },
        "type": {
            "configured": boolean,
            "display_name": "string",
            "enabled": boolean,
            "id": integer,
            "name": "string"
        },
        "update_time": integer
    },
    "overwrite_fields": ["string"]
}

response = falcon.command("UpdateIntegration",
                          id=integer,
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.UpdateIntegration(
    &a_s_p_m.UpdateIntegrationParams{
      Body: &models.TypesUpdateIntegrationRequest{
        Integration: &struct{}{},
        Overwritefields: []string{"string"},
      },
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.updateIntegration(
  integer,  // iD
  {  // body
      integration: {
        data: "string",
        enabled: boolean,
        id: "string",
        integrationType: {
          configured: boolean,
          displayName: "string",
          enabled: boolean,
          id: integer,
          name: "string"
        },
        name: "string",
        node: {
          additionalHeader: "string",
          currentAwsArn: "string",
          dashboardUrl: "string",
          id: "string",
          lastHealthCheck: integer,
          name: "string",
          nodeType: "string",
          password: "string",
          podSettings: {},
          proxyAddress: "string",
          status: {},
          type: "string",
          useJobs: boolean,
          username: "string"
        },
        type: {
          configured: boolean,
          displayName: "string",
          enabled: boolean,
          id: integer,
          name: "string"
        },
        updateTime: integer
      },
      overwriteFields: []
  }
);

console.log(response);

use rusty_falcon::apis::aspm_api::update_integration;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesUpdateIntegrationRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesUpdateIntegrationRequest {
        ..Default::default()
    };

    let response = update_integration(
        &falcon.cfg,  // configuration
        integer,  // id
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesUpdateIntegrationRequest.new(
  integration: {
    data: 'string',
    enabled: boolean,
    id: 'string',
    integration_type: {
      configured: boolean,
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string'
    },
    name: 'string',
    node: {
      additional_header: 'string',
      current_aws_arn: 'string',
      dashboard_url: 'string',
      id: 'string',
      last_health_check: integer,
      name: 'string',
      node_type: 'string',
      password: 'string',
      pod_settings: {},
      proxy_address: 'string',
      status: {},
      type: 'string',
      useJobs: boolean,
      username: 'string'
    },
    type: {
      configured: boolean,
      display_name: 'string',
      enabled: boolean,
      id: integer,
      name: 'string'
    },
    update_time: integer
  },
  overwriteFields: []
)

response = api.update_integration(body, 'string')

puts response

DeleteIntegration

Delete an existing integration by its ID

DELETE /aspm-api-gateway/api/v1/integrations/{ID}

Scope ASPM Admin: WRITE Consumes · Produces application/json

PEP 8 delete_integration

Parameters

Name	Type	Data type	Description
id	path	integer	Integration ID.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.delete_integration(id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.DeleteIntegration(id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("DeleteIntegration",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.DeleteIntegration(
    &a_s_p_m.DeleteIntegrationParams{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.deleteIntegration(integer);  // iD

console.log(response);

use rusty_falcon::apis::aspm_api::delete_integration;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = delete_integration(
        &falcon.cfg,  // configuration
        integer,  // id
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.delete_integration('string')

puts response

ExecuteQuery

Execute a query. The syntax used is identical to that of the query page.

POST /aspm-api-gateway/api/v1/query

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 execute_query

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
paginate	body	dictionary	Pagination detail.
query	body	string	Query to execute.
select_fields	body	dictionary	Field selection detail.
timestamp	body	integer	Timestamp.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.execute_query(paginate={},
                                query="string",
                                select_fields={},
                                timestamp=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ExecuteQuery(paginate={},
                               query="string",
                               select_fields={},
                               timestamp=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "paginate": {
        "direction": "string",
        "limit": integer,
        "offset": integer,
        "order_by": ["string"]
    },
    "query": "string",
    "revision_id": integer,
    "select_fields": {
        "fields": ["string"],
        "service_fields": ["string"],
        "without_services": boolean
    },
    "timestamp": integer
}

response = falcon.command("ExecuteQuery", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  query := "string"
  revisionId := integer
  timestamp := integer

  response, err := client.Aspm.ExecuteQuery(
    &a_s_p_m.ExecuteQueryParams{
      Body: &models.TypesQueryRequest{
        Paginate: &struct{}{},
        Query: &query,
        Revisionid: &revisionId,
        Selectfields: &struct{}{},
        Timestamp: &timestamp,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.executeQuery(
  {
    paginate: {
      direction: "string",
      limit: integer,
      offset: integer,
      orderBy: []
    },
    query: "string",
    revisionId: integer,
    selectFields: {
      fields: [],
      serviceFields: [],
      withoutServices: boolean
    },
    timestamp: integer
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::execute_query;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesQueryRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesQueryRequest {
        query: Some("string".to_string()),
        ..Default::default()
    };

    let response = execute_query(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesQueryRequest.new(
  paginate: {
    direction: 'string',
    limit: integer,
    offset: integer,
    orderBy: []
  },
  query: 'string',
  revisionId: integer,
  selectFields: {
    fields: [],
    serviceFields: [],
    withoutServices: boolean
  },
  timestamp: integer
)

response = api.execute_query(body)

puts response

ServiceNowGetDeployments

Retrieve ServiceNow deployments

GET /aspm-api-gateway/api/v1/servicenow/deployments

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_servicenow_deployments

Parameters

Name	Type	Data type	Description
ql_filters	query	string	Query filter.
limit	query	integer	Maximum number of records to return.
offset	query	integer	Starting position of returned records.
order_by	query	string	Sort field.
direction	query	string	Sort direction.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_servicenow_deployments(ql_filters="string",
                                             limit=integer,
                                             offset=integer,
                                             orderBy="string",
                                             direction="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ServiceNowGetDeployments(ql_filters="string",
                                           limit=integer,
                                           offset=integer,
                                           orderBy="string",
                                           direction="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ServiceNowGetDeployments",
                          ql_filters="string",
                          limit=integer,
                          offset=integer,
                          order_by="string",
                          direction="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  qlFilters := "string"
  limit := int64(0)
  offset := int64(0)
  orderBy := "string"
  direction := "string"

  response, err := client.Aspm.ServiceNowGetDeployments(
    &a_s_p_m.ServiceNowGetDeploymentsParams{
      QlFilters: &qlFilters,
      Limit: &limit,
      Offset: &offset,
      OrderBy: &orderBy,
      Direction: &direction,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.serviceNowGetDeployments(
  "string",  // qlFilters
  integer,  // limit
  integer,  // offset
  "string",  // orderBy
  "string"  // direction
);

console.log(response);

use rusty_falcon::apis::aspm_api::service_now_get_deployments;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = service_now_get_deployments(
        &falcon.cfg,  // configuration
        Some("string"),  // ql_filters
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // order_by
        Some("string"),  // direction
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.service_now_get_deployments(ql_filters: 'string',
                                           limit: integer,
                                           offset: integer,
                                           orderBy: 'string',
                                           direction: 'string')

puts response

ServiceNowGetServices

Retrieve ServiceNow services.

GET /aspm-api-gateway/api/v1/servicenow/services

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_servicenow_services

Parameters

Name	Type	Data type	Description
exclude_artifacts	query	boolean	Flag indicating if artifacts should be excluded.
ql_filters	query	string	Query filter.
limit	query	integer	Maximum number of records to return.
offset	query	integer	Starting position of returned records.
order_by	query	string	Sort field.
direction	query	string	Sort direction.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_servicenow_services(exclude_artifacts=boolean,
                                          ql_filters="string",
                                          limit=integer,
                                          offset=integer,
                                          orderBy="string",
                                          direction="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.ServiceNowGetServices(exclude_artifacts=boolean,
                                        ql_filters="string",
                                        limit=integer,
                                        offset=integer,
                                        orderBy="string",
                                        direction="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("ServiceNowGetServices",
                          ql_filters="string",
                          exclude_artifacts=boolean,
                          limit=integer,
                          offset=integer,
                          order_by="string",
                          direction="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  qlFilters := "string"
  excludeArtifacts := boolean
  limit := int64(0)
  offset := int64(0)
  orderBy := "string"
  direction := "string"

  response, err := client.Aspm.ServiceNowGetServices(
    &a_s_p_m.ServiceNowGetServicesParams{
      QlFilters: &qlFilters,
      ExcludeArtifacts: &excludeArtifacts,
      Limit: &limit,
      Offset: &offset,
      OrderBy: &orderBy,
      Direction: &direction,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.serviceNowGetServices(
  "string",  // qlFilters
  boolean,  // excludeArtifacts
  integer,  // limit
  integer,  // offset
  "string",  // orderBy
  "string"  // direction
);

console.log(response);

use rusty_falcon::apis::aspm_api::service_now_get_services;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = service_now_get_services(
        &falcon.cfg,  // configuration
        Some("string"),  // ql_filters
        Some(boolean),  // exclude_artifacts
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // order_by
        Some("string"),  // direction
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.service_now_get_services(ql_filters: 'string',
                                        exclude_artifacts: boolean,
                                        limit: integer,
                                        offset: integer,
                                        orderBy: 'string',
                                        direction: 'string')

puts response

GetServicesCount

Get the total amount of existing services

POST /aspm-api-gateway/api/v1/services/count

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_services_count

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
deployment_tuple_filters	body	list of dictionaries	Filter excludes and includes.
nesting_level	body	integer	Nesting level.
only_count	body	boolean	Flag indicating if result totals only should be returned.
optional_time	body	integer	Optional time.
pagination	body	dictionary	Pagination.
persistent_signatures	body	string or list of strings	Persistent signatures.
ql_filters	body	string	Query filters.
related_entities	body	list of dictionaries	Related entities.
revision_id	body	integer	Revision ID.
roles_signatures	body	string	Roles signature.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

deployment_tuple_filters = [
    {
        "excludes": [
            {
                "key": "string",
                "value": "string"
            }
        ],
        "includes": [
            {
                "key": "string",
                "value": "string"
            }
        ]
    }
]

pagination = {
    "direction": "string",
    "limit": integer,
    "offset": integer,
    "order_by": ["string"]
}

related_entities = [
    {
        "aggregation_type": integer,
        "entity_type": integer,
        "filters": {
            "include_du_services": boolean,
            "only_du_types": boolean,
            "only_get_brokers": boolean
        },
        "group_by_fields": {
            "fields": ["string"]
        }
    }
]

response = falcon.get_services_count(cids=["string"],
                                     deployment_tuple_filters=deployment_tuple_filters,
                                     nesting_level=integer,
                                     only_count=boolean,
                                     optional_time=integer,
                                     pagination=pagination,
                                     persistent_signatures=["string"],
                                     ql_filters="string",
                                     related_entities=related_entities,
                                     revision_id=integer,
                                     roles_signature="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

deployment_tuple_filters = [
    {
        "excludes": [
            {
                "key": "string",
                "value": "string"
            }
        ],
        "includes": [
            {
                "key": "string",
                "value": "string"
            }
        ]
    }
]

pagination = {
    "direction": "string",
    "limit": integer,
    "offset": integer,
    "order_by": ["string"]
}

related_entities = [
    {
        "aggregation_type": integer,
        "entity_type": integer,
        "filters": {
            "include_du_services": boolean,
            "only_du_types": boolean,
            "only_get_brokers": boolean
        },
        "group_by_fields": {
            "fields": ["string"]
        }
    }
]

response = falcon.GetServicesCount(cids=["string"],
                                   deployment_tuple_filters=deployment_tuple_filters,
                                   nesting_level=integer,
                                   only_count=boolean,
                                   optional_time=integer,
                                   pagination=pagination,
                                   persistent_signatures=["string"],
                                   ql_filters="string",
                                   related_entities=related_entities,
                                   revision_id=integer,
                                   roles_signature="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "cids": ["string"],
    "deployment_tuple_filters": [
        {
            "excludes": [
                {
                    "key": "string",
                    "value": "string"
                }
            ],
            "includes": [
                {
                    "key": "string",
                    "value": "string"
                }
            ]
        }
    ],
    "nesting_level": integer,
    "only_count": boolean,
    "optional_time": integer,
    "pagination": {
        "direction": "string",
        "limit": integer,
        "offset": integer,
        "order_by": ["string"]
    },
    "persistent_signatures": ["string"],
    "ql_filters": "string",
    "related_entities": [
        {
            "aggregation_type": integer,
            "entity_type": integer,
            "filters": {
                "include_du_services": boolean,
                "only_du_types": boolean,
                "only_get_brokers": boolean
            },
            "group_by_fields": {
                "fields": ["string"]
            }
        }
    ],
    "revision_id": integer,
    "roles_signature": "string"
}

response = falcon.command("GetServicesCount", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  key := "string"
  value := "string"
  nestingLevel := integer
  onlyCount := boolean
  optionalTime := integer
  qlFilters := "string"
  aggregation_type := integer
  entity_type := integer
  revisionId := integer
  rolesSignature := "string"

  response, err := client.Aspm.GetServicesCount(
    &a_s_p_m.GetServicesCountParams{
      Body: &models.TypesGetServicesRequest{
        Cids: []string{"string"},
        Deploymenttuplefilters: []interface{}{
          {
          Excludes: []interface{}{
            {
            Key: &key,
            Value: &value,
            },
          },
          Includes: []interface{}{
            {
            Key: &key,
            Value: &value,
            },
          },
          },
        },
        Nestinglevel: &nestingLevel,
        Onlycount: &onlyCount,
        Optionaltime: &optionalTime,
        Pagination: &struct{}{},
        Persistentsignatures: []string{"string"},
        Qlfilters: &qlFilters,
        Relatedentities: []interface{}{
          {
          AggregationType: &aggregation_type,
          EntityType: &entity_type,
          Filters: &struct{}{},
          Groupbyfields: &struct{}{},
          },
        },
        Revisionid: &revisionId,
        Rolessignature: &rolesSignature,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getServicesCount(
  {
    cids: [],
    deploymentTupleFilters: [{
        excludes: [{
            key: "string",
            value: "string"
          }],
        includes: [{
            key: "string",
            value: "string"
          }]
      }],
    nestingLevel: integer,
    onlyCount: boolean,
    optionalTime: integer,
    pagination: {
      direction: "string",
      limit: integer,
      offset: integer,
      orderBy: []
    },
    persistentSignatures: [],
    qlFilters: "string",
    relatedEntities: [{
        aggregationType: integer,
        entityType: integer,
        filters: {
          includeDuServices: boolean,
          onlyDuTypes: boolean,
          onlyGetBrokers: boolean
        },
        groupByFields: {
          fields: []
        }
      }],
    revisionId: integer,
    rolesSignature: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_services_count;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesGetServicesRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesGetServicesRequest {
        ..Default::default()
    };

    let response = get_services_count(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesGetServicesRequest.new(
  cids: [],
  deploymentTupleFilters: [{
      excludes: [{
          key: 'string',
          value: 'string'
        }],
      includes: [{
          key: 'string',
          value: 'string'
        }]
    }],
  nestingLevel: integer,
  onlyCount: boolean,
  optionalTime: integer,
  pagination: {
    direction: 'string',
    limit: integer,
    offset: integer,
    order_by: []
  },
  persistentSignatures: [],
  qlFilters: 'string',
  relatedEntities: [{
      aggregation_type: integer,
      entity_type: integer,
      filters: {
        include_du_services: boolean,
        only_du_types: boolean,
        only_get_brokers: boolean
      },
      groupByFields: {
        fields: []
      }
    }],
  revisionId: integer,
  rolesSignature: 'string'
)

response = api.get_services_count(body)

puts response

GetServiceViolationTypes

Get the different types of violation

GET /aspm-api-gateway/api/v1/services/violations/types

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_service_violation_types

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
filter	body	dictionary	Filter to use for search.
optional_time	body	integer	Optional time.
revision_id	body	integer	Revision ID.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_service_violation_types(filter={},
                                              optional_time=integer,
                                              revision_id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetServiceViolationTypes(filter={},
                                           optional_time=integer,
                                           revision_id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "filter": {
        "order_by": {
            "by_field": "string",
            "direction": integer
        },
        "paginate": {
            "direction": "string",
            "limit": integer,
            "offset": integer,
            "order_by": ["string"]
        }
    },
    "optional_time": integer,
    "revision_id": integer
}

response = falcon.command("GetServiceViolationTypes", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  optionalTime := integer
  revisionId := integer

  response, err := client.Aspm.GetServiceViolationTypes(
    &a_s_p_m.GetServiceViolationTypesParams{
      Body: &models.TypesGenericUserFacingRequest{
        Filter: &struct{}{},
        Optionaltime: &optionalTime,
        Revisionid: &revisionId,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getServiceViolationTypes(
  {
    filter: {
      orderBy: {
        byField: "string",
        direction: integer
      },
      paginate: {
        direction: "string",
        limit: integer,
        offset: integer,
        orderBy: []
      }
    },
    optionalTime: integer,
    revisionId: integer
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_service_violation_types;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesGenericUserFacingRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesGenericUserFacingRequest {
        ..Default::default()
    };

    let response = get_service_violation_types(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesGenericUserFacingRequest.new(
  filter: {
    order_by: {
      by_field: 'string',
      direction: integer
    },
    paginate: {
      direction: 'string',
      limit: integer,
      offset: integer,
      orderBy: []
    }
  },
  optionalTime: integer,
  revisionId: integer
)

response = api.get_service_violation_types(body)

puts response

GetTags

Get all the tags

GET /aspm-api-gateway/api/v1/tags

Scope ASPM Read Only: READ Consumes · Produces application/json

PEP 8 get_tags

Parameters

Name	Type	Data type	Description
is_unique	query	boolean	Tag is unique.
limit	query	integer	Maximum number of records to return.
offset	query	integer	Starting position of returned records.
tag_name	query	string	Tag name.
name	query	string or list of strings	Name.
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_tags(is_unique=boolean,
                           tag_name="string",
                           limit=integer,
                           offset=integer,
                           name="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetTags(is_unique=boolean,
                          tag_name="string",
                          limit=integer,
                          offset=integer,
                          name="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetTags",
                          is_unique=boolean,
                          tag_name="string",
                          limit=integer,
                          offset=integer,
                          name=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  isUnique := boolean
  tagName := "string"
  limit := int64(0)
  offset := int64(0)

  response, err := client.Aspm.GetTags(
    &a_s_p_m.GetTagsParams{
      IsUnique: &isUnique,
      TagName: &tagName,
      Limit: &limit,
      Offset: &offset,
      Name: []string{"ID1", "ID2", "ID3"},
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getTags(
  boolean,  // isUnique
  "string",  // tagName
  integer,  // limit
  integer,  // offset
  ["ID1", "ID2", "ID3"]  // name
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_tags;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_tags(
        &falcon.cfg,  // configuration
        Some(boolean),  // is_unique
        Some("string"),  // tag_name
        Some(integer),  // limit
        Some(integer),  // offset
        Some(vec!["string".to_string()]),  // name
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_tags(isUnique: boolean,
                        tagName: 'string',
                        limit: integer,
                        offset: integer,
                        name: ['ID1', 'ID2', 'ID3'])

puts response

UpsertTags

Create new or update existing tag. You can update unique tags table or regular tags table

PUT /aspm-api-gateway/api/v1/tags

Scope ASPM Analyst: WRITE Consumes · Produces application/json

PEP 8 update_tags

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
is_sensitive	body	boolean	Flag indicating if the tag is sensitive.
persistent_signature	body	string	Tag persistent signature.
value	body	string	Tag value.
name	body	string	Tag name.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

entries = [
    {
        "isSensitive": true,
        "name": "string",
        "tag_type": "string",
        "value": "string"
    }
]

response = falcon.update_tags(entries=entries,
                              is_sensitive=boolean,
                              name="string",
                              tag_type="string",
                              value="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

entries = [
    {
        "isSensitive": true,
        "name": "string",
        "tag_type": "string",
        "value": "string"
    }
]

response = falcon.UpsertTags(entries=entries,
                             is_sensitive=boolean,
                             name="string",
                             tag_type="string",
                             value="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "entries": [
        {
            "is_sensitive": boolean,
            "name": "string",
            "tag_type": "string",
            "value": "string"
        }
    ]
}

response = falcon.command("UpsertTags", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  isSensitive := boolean
  name := "string"
  tag_type := "string"
  value := "string"

  response, err := client.Aspm.UpsertTags(
    &a_s_p_m.UpsertTagsParams{
      Body: &models.TypesEditUniqueTagRequest{
        Entries: []interface{}{
          {
          Issensitive: &isSensitive,
          Name: &name,
          TagType: &tag_type,
          Value: &value,
          },
        },
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.upsertTags(
  {
    entries: [{
        isSensitive: boolean,
        name: "string",
        tagType: "string",
        value: "string"
      }]
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::upsert_tags;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesEditUniqueTagRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesEditUniqueTagRequest {
        entries: vec![],
        ..Default::default()
    };

    let response = upsert_tags(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesEditUniqueTagRequest.new(
  entries: [{
      isSensitive: boolean,
      name: 'string',
      tag_type: 'string',
      value: 'string'
    }]
)

response = api.upsert_tags(body)

puts response

DeleteTags

Remove existing tags

POST /aspm-api-gateway/api/v1/tags

Scope ASPM Analyst: WRITE Consumes · Produces application/json

PEP 8 delete_tags

Parameters

Name	Type	Data type	Description
body	body	dictionary	Full body payload in JSON format.
is_sensitive	body	boolean	Flag indicating if the tag is sensitive.
persistent_signature	body	string	Tag persistent signature.
value	body	string	Tag value.
name	body	string	Tag name.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.delete_tags(entries=[{"key": "value"}],
                              is_sensitive=boolean,
                              name="string",
                              persistent_signature="string",
                              value="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.DeleteTags(entries=[{"key": "value"}],
                             is_sensitive=boolean,
                             name="string",
                             persistent_signature="string",
                             value="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "entries": [
        {
            "is_sensitive": boolean,
            "persistent_signature": "string",
            "value": "string"
        }
    ],
    "name": "string"
}

response = falcon.command("DeleteTags", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  isSensitive := boolean
  persistentSignature := "string"
  value := "string"
  name := "string"

  response, err := client.Aspm.DeleteTags(
    &a_s_p_m.DeleteTagsParams{
      Body: &models.TypesEditTagRequest{
        Entries: []interface{}{
          {
          Issensitive: &isSensitive,
          Persistentsignature: &persistentSignature,
          Value: &value,
          },
        },
        Name: &name,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.deleteTags(
  {
    entries: [{
        isSensitive: boolean,
        persistentSignature: "string",
        value: "string"
      }],
    name: "string"
}  // body
);

console.log(response);

use rusty_falcon::apis::aspm_api::delete_tags;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesEditTagRequest;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let body = TypesEditTagRequest {
        entries: vec![TagEntry {
            persistent_signature: Some("string".to_string()),
            ..Default::default()
        }],
        name: Some("string".to_string()),
        ..Default::default()
    };

    let response = delete_tags(
        &falcon.cfg,  // configuration
        body,  // body
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

body = Falcon::TypesEditTagRequest.new(
  entries: [{
      isSensitive: boolean,
      persistentSignature: 'string',
      value: 'string'
    }],
  name: 'string'
)

response = api.delete_tags(body)

puts response

GetGroupHierarchy

Get group hierarchy

GET /aspm-api-gateway/api/v1/groups/hier/v2

Scope Aspm Admin: READ Consumes · Produces application/json

PEP 8 get_group_hierarchy

Parameters

Name	Type	Data type	Description
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_group_hierarchy()
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetGroupHierarchy()
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetGroupHierarchy")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.GetGroupsHierV2(
    &a_s_p_m.GetGroupsHierV2Params{
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getGroupsHierV2();

console.log(response);

GetGroupV2

Get group details

GET /aspm-api-gateway/api/v1/group/{}/v2

Scope Aspm Admin: READ Consumes · Produces application/json

PEP 8 get_group_v2

Parameters

Name	Type	Data type	Description
ID	path	integer	Group ID
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_group_v2(id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetGroupV2(id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetGroupV2",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.GetGroupID09V2(
    &a_s_p_m.GetGroupID09V2Params{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getGroupID09V2(integer);  // iD

console.log(response);

DeleteGroup

DELETE /aspm-api-gateway/api/v1/group/{}

Scope Aspm Falcon Admin: WRITE Consumes · Produces application/json

PEP 8 delete_group

Parameters

Name	Type	Data type	Description
ID	path	integer	Group ID
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.delete_group(id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.DeleteGroup(id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("DeleteGroup",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.DeleteGroupID09(
    &a_s_p_m.DeleteGroupID09Params{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.deleteGroupID09(integer);  // iD

console.log(response);

GetGroupsV2

GET /aspm-api-gateway/api/v1/groups/list/v2

Scope Aspm Admin: READ Consumes · Produces application/json

PEP 8 get_groups_v2

Parameters

Name	Type	Data type	Description
type	query	string	Group types to query - can either be empty (all), parents, children
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_groups_v2(type="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetGroupsV2(type="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetGroupsV2",
                          type="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  type := "string"

  response, err := client.Aspm.GetGroupsListV2(
    &a_s_p_m.GetGroupsListV2Params{
      Type: &type,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getGroupsListV2("string");  // type

console.log(response);

GetIntegrationTasksAdmin

Get all the integration tasks, requires admin scope

GET /aspm-api-gateway/api/v1/integration_tasks/admin

Scope Aspm Admin: READ Consumes · Produces application/json

PEP 8 get_integration_tasks_admin

Parameters

Name	Type	Data type	Description
integration_task_type	query	integer
category	query	string
offset	query	integer
limit	query	integer
orderBy	query	string
direction	query	string
integration_task_types	query	integer
ids	query	integer
names	query	string
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.get_integration_tasks_admin(integration_task_type=integer,
                                              category="string",
                                              offset=integer,
                                              limit=integer,
                                              order_by="string",
                                              direction="string",
                                              integration_task_types=integer,
                                              ids=id_list,
                                              names="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.GetIntegrationTasksAdmin(integration_task_type=integer,
                                           category="string",
                                           offset=integer,
                                           limit=integer,
                                           order_by="string",
                                           direction="string",
                                           integration_task_types=integer,
                                           ids=id_list,
                                           names="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

id_list = 'ID1,ID2,ID3'  # Can also pass a list here: ['ID1', 'ID2', 'ID3']

response = falcon.command("GetIntegrationTasksAdmin",
                          integration_task_type=integer,
                          category="string",
                          offset=integer,
                          limit=integer,
                          order_by="string",
                          direction="string",
                          integration_task_types=integer,
                          ids=integer,
                          names="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  integrationTaskType := int64(0)
  category := "string"
  offset := int64(0)
  limit := int64(0)
  orderBy := "string"
  direction := "string"
  integrationTaskTypes := int64(0)
  ids := int64(0)
  names := "string"

  response, err := client.Aspm.GetIntegrationTasksAdmin(
    &a_s_p_m.GetIntegrationTasksAdminParams{
      IntegrationTaskType: &integrationTaskType,
      Category: &category,
      Offset: &offset,
      Limit: &limit,
      OrderBy: &orderBy,
      Direction: &direction,
      IntegrationTaskTypes: &integrationTaskTypes,
      Ids: &ids,
      Names: &names,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getIntegrationTasksAdmin(
  integer,  // integrationTaskType
  "string",  // category
  integer,  // offset
  integer,  // limit
  integer,  // orderBy
  integer,  // direction
  integer,  // integrationTaskTypes
  integer,  // ids
  "string"  // names
);

console.log(response);

use rusty_falcon::apis::aspm_api::get_integration_tasks_admin;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = get_integration_tasks_admin(
        &falcon.cfg,  // configuration
        Some(integer),  // integration_task_type
        Some("string"),  // category
        Some(integer),  // offset
        Some(integer),  // limit
        Some("string"),  // order_by
        Some("string"),  // direction
        Some(integer),  // integration_task_types
        Some(integer),  // ids
        Some("string"),  // names
    ).await.expect("API call failed");

    println!("{:?}", response);
}

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::ASPM.new

response = api.get_integration_tasks_admin(integration_task_type: integer,
                                           category: 'string',
                                           offset: integer,
                                           limit: integer,
                                           orderBy: 'string',
                                           direction: 'string',
                                           integration_task_types: integer,
                                           ids: integer,
                                           names: 'string')

puts response

GetUsersV2

List users

GET /aspm-api-gateway/api/v1/users/v2

Scope Aspm Admin: READ Consumes · Produces application/json

PEP 8 get_users_v2

Parameters

Name	Type	Data type	Description
pagination	query	string	URL encoded pagination JSON - limit, offset, direction, orderBy
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.get_users_v2(pagination="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.GetUsersV2(pagination="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("GetUsersV2",
                          pagination="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  pagination := "string"

  response, err := client.Aspm.GetUsersV2(
    &a_s_p_m.GetUsersV2Params{
      Pagination: &pagination,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.getUsersV2("string");  // pagination

console.log(response);

PostGroupV2

Create group

POST /aspm-api-gateway/api/v1/group/v2

Scope Aspm Falcon Admin: WRITE Consumes · Produces application/json

PEP 8 post_group_v2

Parameters

Name	Type	Data type	Description
parameters	query	dictionary	Full query string parameters payload in JSON format.
body	body	dictionary	Full body payload as a JSON formatted dictionary.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.post_group_v2(children=integer,
                                description="string",
                                group_type="string",
                                is_default=boolean,
                                name="string",
                                parent_id=integer,
                                scope="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.PostGroupV2(children=integer,
                              description="string",
                              group_type="string",
                              is_default=boolean,
                              name="string",
                              parent_id=integer,
                              scope="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "children": ["string"],
    "description": "string",
    "group_type": "string",
    "is_default": boolean,
    "name": "string",
    "parent_id": integer,
    "scope": "string"
}

response = falcon.command("PostGroupV2", body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  description := "string"
  groupType := "string"
  isDefault := boolean
  name := "string"
  parentId := integer
  scope := "string"

  response, err := client.Aspm.PostGroupV2(
    &a_s_p_m.PostGroupV2Params{
      Body: &models.TypesCreateGroupRequest{
        Children: []interface{}{},
        Description: &description,
        Grouptype: &groupType,
        Isdefault: &isDefault,
        Name: &name,
        Parentid: &parentId,
        Scope: &scope,
      },
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.postGroupV2(
  {
    children: [],
    description: "string",
    groupType: "string",
    isDefault: boolean,
    name: "string",
    parentId: integer,
    scope: "string"
}  // body
);

console.log(response);

UpdateDefaultGroup

Update default group

POST /aspm-api-gateway/api/v1/group/{}/update_default

Scope Aspm Falcon Admin: WRITE Consumes · Produces application/json

PEP 8 update_default_group

Parameters

Name	Type	Data type	Description
ID	path	integer	Group ID
parameters	query	dictionary	Full query string parameters payload in JSON format.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.update_default_group(id=integer)
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.UpdateDefaultGroup(id=integer)
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

response = falcon.command("UpdateDefaultGroup",
                          id=integer)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Aspm.PostGroupID09UpdateDefault(
    &a_s_p_m.PostGroupID09UpdateDefaultParams{
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.postGroupID09UpdateDefault(integer);  // iD

console.log(response);

UpdateGroup

Update group

POST /aspm-api-gateway/api/v1/group/{}/v2

Scope Aspm Falcon Admin: WRITE Consumes · Produces application/json

PEP 8 update_group

Parameters

Name	Type	Data type	Description
ID	path	integer	Group ID
parameters	query	dictionary	Full query string parameters payload in JSON format.
body	body	dictionary	Full body payload as a JSON formatted dictionary.

Code Examples

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.update_group(id=integer,
                               children=integer,
                               description="string",
                               group_type="string",
                               is_default=boolean,
                               name="string",
                               parent_id=integer,
                               scope="string")
print(response)

from falconpy import ASPM

falcon = ASPM(client_id=CLIENT_ID,
              client_secret=CLIENT_SECRET
              )

response = falcon.UpdateGroup(id=integer,
                              children=integer,
                              description="string",
                              group_type="string",
                              is_default=boolean,
                              name="string",
                              parent_id=integer,
                              scope="string")
print(response)

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

body_payload = {
    "children": ["string"],
    "description": "string",
    "group_id": integer,
    "group_type": "string",
    "is_default": boolean,
    "name": "string",
    "parent_id": integer,
    "scope": "string"
}

response = falcon.command("UpdateGroup",
                          id=integer,
                          body=body_payload)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/a_s_p_m"
  "github.com/crowdstrike/gofalcon/falcon/models"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  description := "string"
  groupId := integer
  groupType := "string"
  isDefault := boolean
  name := "string"
  parentId := integer
  scope := "string"

  response, err := client.Aspm.PostGroupID09V2(
    &a_s_p_m.PostGroupID09V2Params{
      Body: &models.TypesUpdateGroupRequest{
        Children: []interface{}{},
        Description: &description,
        Groupid: &groupId,
        Grouptype: &groupType,
        Isdefault: &isDefault,
        Name: &name,
        Parentid: &parentId,
        Scope: &scope,
      },
      ID: integer,
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.aspm.postGroupID09V2(
  integer,  // iD
  {  // body
      children: [],
      description: "string",
      groupId: integer,
      groupType: "string",
      isDefault: boolean,
      name: "string",
      parentId: integer,
      scope: "string"
  }
);

console.log(response);

ASPM

Table of Contents

ExecuteFunctionDataCount

Parameters

Code Examples

ExecuteFunctionsCount

Parameters

Code Examples

ExecuteFunctionDataQueryCount

Parameters

Code Examples

ExecuteFunctionsQueryCount

Parameters

Code Examples

ExecuteFunctionData

Parameters

Code Examples

ExecuteFunctionsOvertime

Parameters

Code Examples

ExecuteFunctions

Parameters

Code Examples

ExecuteFunctionDataQuery

Parameters

Code Examples

ExecuteFunctionsQueryOvertime

Parameters

Code Examples

ExecuteFunctionsQuery

Parameters

Code Examples

getServiceArtifacts

Parameters

Code Examples

UpsertBusinessApplications

Parameters

Code Examples

GetCloudSecurityIntegrationState

Code Examples

SetCloudSecurityIntegrationState

Parameters

Code Examples

GetExecutorNodes

Parameters

Code Examples

UpdateExecutorNode

Parameters

Code Examples

CreateExecutorNode

Parameters

Code Examples

GetExecutorNodesMetadata

Parameters

Code Examples

DeleteExecutorNode

Parameters

Code Examples

RetrieveRelayInstances

Parameters

Code Examples

GetIntegrationTasks

Parameters

Code Examples

CreateIntegrationTask

Parameters

Code Examples

GetIntegrationTasksMetadata

Parameters

Code Examples

GetIntegrationTasksV2

Parameters

Code Examples

UpdateIntegrationTask

Parameters

Code Examples

DeleteIntegrationTask

Parameters

Code Examples

RunIntegrationTask