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.5
PowerShell
Go	v0.22.0
TypeScript	v0.6.0
Rust	v0.7.1
Ruby	v1.4.0

Operation	Description
CreateExecutorNode `create_executor_node`	Create a new relay node
CreateIntegration `create_integration`	Create a new integration
CreateIntegrationTask `create_integration_task`	Create new integration task.
DeleteExecutorNode `delete_node`	Delete a relay node
DeleteGroup `delete_group`
DeleteIntegration `delete_integration`	Delete an existing integration by its ID
DeleteIntegrationTask `delete_integration_task`	Delete an existing integration task by its ID
DeleteTags `delete_tags`	Remove existing tags
ExecuteFunctionData `execute_function_data`	A selected list of queryLanguage queries. request & response are in MSA format
ExecuteFunctionDataCount `execute_function_data_count`	A selected list of queryLanguage count queries. request & response are in MSA format
ExecuteFunctionDataQuery `execute_function_data_query`	A selected list of queryLanguage queries. request & response are in MSA format
ExecuteFunctionDataQueryCount `execute_function_data_query_count`	A selected list of queryLanguage count queries. request & response are in MSA format
ExecuteFunctions `execute_functions`	A selected list of queryLanguage services queries. request & response are in MSA format
ExecuteFunctionsCount `execute_functions_count`	A selected list of queryLanguage count queries. request & response are in MSA format
ExecuteFunctionsOvertime `execute_functions_over_time`	A selected list of queryLanguage overtime queries. request & response are in MSA format
ExecuteFunctionsQuery `execute_functions_query`	A selected list of queryLanguage services queries. request & response are in MSA format
ExecuteFunctionsQueryCount `execute_functions_query_count`	A selected list of queryLanguage count queries. request & response are in MSA format
ExecuteFunctionsQueryOvertime `execute_functions_query_over_time`	A selected list of queryLanguage overtime queries. request & response are in MSA format
ExecuteQuery `execute_query`	Execute a query.
GetCloudSecurityIntegrationState `get_cloud_security_integration_state`	Get Cloud Security integration state
GetExecutorNodes `get_executor_nodes`	Get all the relay nodes
GetExecutorNodesMetadata `get_executor_nodes_metadata`	Get metadata about all executor nodes
GetGroupHierarchy `get_group_hierarchy`	Get group hierarchy
GetGroupsV2 `get_groups_v2`
GetGroupV2 `get_group_v2`	Get group details
GetIntegrations `get_integrations`	Get a list of all the integrations
GetIntegrationsV2 `get_integrations_v2`	Get a list of all the integrations
GetIntegrationTasks `get_integration_tasks`	Get all the integration tasks
GetIntegrationTasksAdmin `get_integration_tasks_admin`	Get all the integration tasks, requires admin scope
GetIntegrationTasksMetadata `get_integration_tasks_metadata`	Get metadata about all integration tasks
GetIntegrationTasksV2 `get_integration_tasks_v2`	Get all the integration tasks
GetIntegrationTypes `get_integration_types`	Get all the integration types
getServiceArtifacts `get_service_artifacts`
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
GetUsersV2 `get_users_v2`	List users
PostGroupV2 `post_group_v2`	Create group
RetrieveRelayInstances `retrieve_relay_instances`	Retrieve the relay instances in CSV format
RunIntegrationTask `run_integration_task`	Run an integration task by its ID
RunIntegrationTaskAdmin `run_integration_task_admin`	Run an integration task by its ID - for admin scope
RunIntegrationTaskV2 `run_integration_task_v2`	Run an integration task by its ID
ServiceNowGetDeployments `get_servicenow_deployments`
ServiceNowGetServices `get_servicenow_services`
SetCloudSecurityIntegrationState `set_cloud_security_integration_state`	Set Cloud Security integration state
UpdateDefaultGroup `update_default_group`	Update default group
UpdateExecutorNode `update_executor_node`	Update an existing relay node
UpdateGroup `update_group`	Update group
UpdateIntegration `update_integration`	Update an existing integration by its ID
UpdateIntegrationTask `update_integration_task`	Update an existing integration task by its ID
UpsertBusinessApplications `update_business_applications`	Create or Update Business Applications
UpsertTags `update_tags`	Create new or update existing tag.

CreateExecutorNode

Create a new relay node

Method POST

Route /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: WRITE

PEP 8 create_executor_node

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

additional_header body · string

current_aws_arn body · string

dashboard_url body · string

id body · string

last_health_check body · integer

name body · string

node_type body · string

password body · string

pod_settings body · object

proxy_address body · string

status body · object

type body · string

use_jobs body · boolean

useJobs body · boolean

UseJobs body · boolean

username body · string

Code Examples

from falconpy import ASPM

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

pod_settings = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

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",
                                       type="string",
                                       use_jobs="string",
                                       username="string")
print(response)

from falconpy import ASPM

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

pod_settings = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

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",
                                     type="string",
                                     use_jobs="string",
                                     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"
  typeVar := "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: &typeVar,
        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

Responses

{
  "additional_header": "string",
  "current_aws_arn": "string",
  "dashboard_url": "string",
  "id": "string",
  "last_health_check": 0,
  "name": "string",
  "node_type": "string",
  "password": "string",
  "pod_settings": {
    "imageAddress": "string",
    "imagePullSecrets": [],
    "podLabels": []
  },
  "proxy_address": "string",
  "status": {
    "State": 0,
    "StateLastUpdated": 0,
    "StateReason": 0
  },
  "type": "string",
  "useJobs": false,
  "username": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

CreateIntegration

Create a new integration

Method POST

Route /aspm-api-gateway/api/v1/integrations

Scope ASPM Admin: WRITE

PEP 8 create_integration

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

integration body · object

Integration details.

Code Examples

from falconpy import ASPM

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

integration = {
    "data": "string",
    "enabled": "boolean",
    "id": "integer",
    "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": "integer",
        "last_health_check": "integer",
        "name": "string",
        "node_type": "string",
        "password": "string",
        "pod_settings": {
            "imageAddress": "string",
            "imagePullSecrets": [
                "string"
            ],
            "podLabels": [
                {
                    "key": "string",
                    "value": "string"
                }
            ]
        },
        "proxy_address": "string",
        "type": "string",
        "useJobs": "boolean",
        "username": "string"
    },
    "type": {
        "configured": "boolean",
        "display_name": "string",
        "enabled": "boolean",
        "id": "integer",
        "name": "string"
    },
    "update_time": "integer"
}

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

from falconpy import ASPM

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

integration = {
    "data": "string",
    "enabled": "boolean",
    "id": "integer",
    "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": "integer",
        "last_health_check": "integer",
        "name": "string",
        "node_type": "string",
        "password": "string",
        "pod_settings": {
            "imageAddress": "string",
            "imagePullSecrets": [
                "string"
            ],
            "podLabels": [
                {
                    "key": "string",
                    "value": "string"
                }
            ]
        },
        "proxy_address": "string",
        "type": "string",
        "useJobs": "boolean",
        "username": "string"
    },
    "type": {
        "configured": "boolean",
        "display_name": "string",
        "enabled": "boolean",
        "id": "integer",
        "name": "string"
    },
    "update_time": "integer"
}

response = falcon.CreateIntegration(integration=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

Responses

{
  "integration": {
    "data": "string",
    "enabled": false,
    "id": "string",
    "integration_type": {
      "configured": false,
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string"
    },
    "name": "string",
    "node": {
      "additional_header": "string",
      "current_aws_arn": "string",
      "dashboard_url": "string",
      "id": "string",
      "last_health_check": 0,
      "name": "string",
      "node_type": "string",
      "password": "string",
      "pod_settings": {},
      "proxy_address": "string",
      "status": {},
      "type": "string",
      "useJobs": false,
      "username": "string"
    },
    "type": {
      "configured": false,
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string"
    },
    "update_time": 0
  },
  "new_executor_node": {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": 0,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
      "imageAddress": "string",
      "imagePullSecrets": [],
      "podLabels": []
    },
    "proxy_address": "string",
    "status": {
      "State": 0,
      "StateLastUpdated": 0,
      "StateReason": 0
    },
    "type": "string",
    "useJobs": false,
    "username": "string"
  }
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

CreateIntegrationTask

Create new integration task.

Method POST

Route /aspm-api-gateway/api/v1/integration_tasks

Scope ASPM Admin: WRITE

PEP 8 create_integration_task

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

integration_task body · object

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

Responses

{
  "integrationTask": {
    "accessToken": "string",
    "additionalHeader": "string",
    "businessApplication": "string",
    "data": "string",
    "enabled": false,
    "id": "string",
    "integration": {
      "data": "string",
      "enabled": false,
      "id": "string",
      "integration_type": {},
      "name": "string",
      "node": {},
      "type": {},
      "update_time": 0
    },
    "integrationTaskType": {
      "category": "string",
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string",
      "required_integration_types": []
    },
    "latestTaskRun": {
      "createTime": "string",
      "events": [],
      "id": "string",
      "latestEvent": {},
      "metadata": {},
      "progress": 0,
      "scheduled": false,
      "traceUuid": "string"
    },
    "name": "string",
    "nextRun": {
      "nanos": 0,
      "seconds": 0
    },
    "progress": 0,
    "schedule": {
      "every": 0,
      "every_unit": 0,
      "hour": 0,
      "minute": 0,
      "startTimeTimezoneOffsetMinutes": 0,
      "start_time": {},
      "timezone": 0,
      "weekdays": []
    },
    "scheduleEveryUnitDisplayName": "string",
    "trigger": "string",
    "type": {
      "category": "string",
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string",
      "required_integration_types": []
    }
  },
  "newExecutorNode": {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": 0,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
      "imageAddress": "string",
      "imagePullSecrets": [],
      "podLabels": []
    },
    "proxy_address": "string",
    "status": {
      "State": 0,
      "StateLastUpdated": 0,
      "StateReason": 0
    },
    "type": "string",
    "useJobs": false,
    "username": "string"
  }
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

DeleteExecutorNode

Delete a relay node

Method DELETE

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

Scope ASPM Admin: WRITE

PEP 8 delete_node

Parameters

ID path · integer

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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

DeleteGroup

Method DELETE

Route /aspm-api-gateway/api/v1/group/{ID}

Scope ASPM Falcon Admin: WRITE

PEP 8 delete_group

Parameters

ID path · integer

Group ID

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);

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

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

    let response = delete_slash_group_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket(&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.delete_group_id_09('string')

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

DeleteIntegration

Delete an existing integration by its ID

Method DELETE

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

Scope ASPM Admin: WRITE

PEP 8 delete_integration

Parameters

ID path · integer

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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

DeleteIntegrationTask

Delete an existing integration task by its ID

Method DELETE

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

Scope ASPM Admin: WRITE

PEP 8 delete_integration_task

Parameters

ID path · integer

ID of the integration task to remove.

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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

DeleteTags

Remove existing tags

Method POST

Route /aspm-api-gateway/api/v1/tags

Scope ASPM Analyst: WRITE

PEP 8 delete_tags

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

entries body · array

Tag entries. Overrides the is_sensitive, persistent_signature, and value keywords.

name body · string

Tag name.

is_sensitive body · boolean

Sensitive.

persistent_signature body · string

Persistent signature.

value body · string

Tag value.

Code Examples

from falconpy import ASPM

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

response = falcon.delete_tags(entries=["string"],
                              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=["string"],
                             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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionData

A selected list of queryLanguage queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_function_data

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "resultJSON": [],
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionDataCount

A selected list of queryLanguage count queries. request & response are in MSA format

Method POST

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

Scope ASPM Read-Only: READ

PEP 8 execute_function_data_count

Parameters

query_name query · string

Query name. Available values:

Available values (7)

`sensitive_data`	`reachable`	`sensitive_datasources`
`dependencies`	`vulnerable_libraries`	`risk_severity`
`sensitive_data_tags`

cloud_provider query · string

Cloud provider name. Available values:

Available values (3)

aws azure gcp

aws_lambda_arn query · string

required for ‘aws’ cloud provider

gcp_cloud_function_url query · string

required for ‘gcp’ cloud provider

azure_site_subscription_id query · string

required for ‘azure’ cloud provider

azure_site_resource_group query · string

required for ‘azure’ cloud provider

azure_function_app_name query · string

required for ‘azure’ cloud provider

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "count": 0,
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionDataQuery

A selected list of queryLanguage queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_function_data_query

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "resultJSON": [],
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionDataQueryCount

A selected list of queryLanguage count queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_function_data_query_count

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "count": 0,
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctions

A selected list of queryLanguage services queries. request & response are in MSA format

Method GET

Route /application-security/combined/functions/v1

Scope ASPM Read-Only: READ

PEP 8 execute_functions

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "resultJSON": [],
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionsCount

A selected list of queryLanguage count queries. request & response are in MSA format

Method POST

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

Scope ASPM Read-Only: READ

PEP 8 execute_functions_count

Parameters

query_name query · string

Query name. Available values:

Available values (5)

`sensitive_data`	`reachable`	`sensitive_datasources`
`dependencies`	`vulnerable_libraries`

cloud_provider query · string or list of strings

Cloud provider name. Available values:

Available values (3)

aws azure gcp

cloud_account_id query · string or list of strings

required for ‘aws’ cloud provider

region query · string or list of strings

required for ‘gcp’ cloud provider

cid query · string or list of strings

required for ‘azure’ cloud provider

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "count": 0,
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionsOvertime

A selected list of queryLanguage overtime queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_functions_over_time

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "result": {},
    "timestamp": 0
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionsQuery

A selected list of queryLanguage services queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_functions_query

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "resultJSON": [],
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionsQueryCount

A selected list of queryLanguage count queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_functions_query_count

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "count": 0,
    "resultType": "string"
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteFunctionsQueryOvertime

A selected list of queryLanguage overtime queries. request & response are in MSA format

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 execute_functions_query_over_time

Parameters

field query · string

Field to retrieve.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

[
  {
    "result": {},
    "timestamp": 0
  }
]

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ExecuteQuery

Execute a query.

Method POST

Route /aspm-api-gateway/api/v1/query

Scope ASPM Read-Only: READ

PEP 8 execute_query

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

paginate body · object

Pagination detail.

query body · string

Query to perform.

revision_id body · integer

revisionId body · integer

RevisionId body · integer

select_fields body · object

Field selection detail. Dictionary contents: fields - For filtering relevant fields only. withoutServices - Default is set to True, you will not receive information about the services. If you want to get the relevant service, set to False. serviceFields - For filtering relevant fields of the service (if you chose to get it)

selectFields body · object

SelectFields body · object

timestamp body · integer

Timestamp.

Code Examples

from falconpy import ASPM

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

paginate = {
    "direction": "string",
    "limit": "integer",
    "offset": "integer",
    "orderBy": [
        "string"
    ]
}

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

from falconpy import ASPM

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

paginate = {
    "direction": "string",
    "limit": "integer",
    "offset": "integer",
    "orderBy": [
        "string"
    ]
}

response = falcon.ExecuteQuery(paginate=paginate,
                               query="string",
                               select_fields="string",
                               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

Responses

{
  "resultJSON": [
    {}
  ],
  "resultType": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetCloudSecurityIntegrationState

Get Cloud Security integration state

Method GET

Route /aspm-api-gateway/api/v1/cloud_security_config

Scope ASPM Admin: READ

PEP 8 get_cloud_security_integration_state

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

Responses

{
  "customerHasCSPM": false,
  "isEnabled": false
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetExecutorNodes

Get all the relay nodes

Method GET

Route /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: READ

PEP 8 get_executor_nodes

Parameters

node_type query · string

Node type.

integration_type query · integer

Integration type.

offset query · integer

Starting position for records returned.

limit query · integer

Maximum number of records to return.

order_by query · string

Field to use for sorting results. Allowed values:

Available values (4)

`name`	`id`	`state`
`type`

direction query · string

Sort order direction. Allowed values:

Available values (2)

asc 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 · 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. Not required when using other keywords.

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=integer,
                                     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=integer,
                                   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

Responses

{
  "executor_nodes": [
    {
      "additional_header": "string",
      "current_aws_arn": "string",
      "dashboard_url": "string",
      "id": "string",
      "last_health_check": 0,
      "name": "string",
      "node_type": "string",
      "password": "string",
      "pod_settings": {},
      "proxy_address": "string",
      "status": {},
      "type": "string",
      "useJobs": false,
      "username": "string"
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetExecutorNodesMetadata

Get metadata about all executor nodes

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 get_executor_nodes_metadata

Parameters

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. Not required when using other keywords.

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=id_list,
                                              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=id_list,
                                           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

Responses

{
  "count": 0,
  "executorNodeIds": [
    0
  ],
  "executorNodeNames": [
    "string"
  ],
  "executorNodeStates": [
    "string"
  ],
  "executorNodeTypes": [
    "string"
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetGroupHierarchy

Get group hierarchy

Method GET

Route /aspm-api-gateway/api/v1/groups/hier/v2

Scope ASPM Admin: READ

PEP 8 get_group_hierarchy

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);

use rusty_falcon::apis::aspm_api::get_slash_groups_slash_hier_slash_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_slash_groups_slash_hier_slash_v2(&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_groups_hier_v2

puts response

Responses

{
  "Total": 0,
  "groups": [
    {
      "children": [],
      "createdBy": "string",
      "description": "string",
      "groupId": 0,
      "groupType": "string",
      "isDefault": false,
      "isOOB": false,
      "name": "string",
      "scope": "string"
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetGroupsV2

Method GET

Route /aspm-api-gateway/api/v1/groups/list/v2

Scope ASPM Admin: READ

PEP 8 get_groups_v2

Parameters

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. Not required when using other keywords.

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)
  }

  typeVar := "string"

  response, err := client.Aspm.GetGroupsListV2(
    &a_s_p_m.GetGroupsListV2Params{
      Type: &typeVar,
      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);

use rusty_falcon::apis::aspm_api::get_slash_groups_slash_list_slash_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_slash_groups_slash_list_slash_v2(&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_groups_list_v2(type: 'string')

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetGroupV2

Get group details

Method GET

Route /aspm-api-gateway/api/v1/group/{ID}/v2

Scope ASPM Admin: READ

PEP 8 get_group_v2

Parameters

ID path · integer

Group ID

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);

use rusty_falcon::apis::aspm_api::get_slash_group_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket_slash_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_slash_group_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket_slash_v2(&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_group_id_09_v2('string')

puts response

Responses

{
  "children": [
    {
      "groupId": 0,
      "name": "string"
    }
  ],
  "createdAt": 0,
  "createdBy": "string",
  "description": "string",
  "groupId": 0,
  "groupType": "string",
  "isDefault": false,
  "isOOB": false,
  "name": "string",
  "parent": {
    "groupId": 0,
    "name": "string"
  },
  "scope": "string",
  "updatedAt": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrations

Get a list of all the integrations

Method GET

Route /aspm-api-gateway/api/v1/integrations

Scope ASPM Read-Only: READ

PEP 8 get_integrations

Parameters

integration_type query · integer

Type of integration.

category query · string

Integration category.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

Code Examples

from falconpy import ASPM

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

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

from falconpy import ASPM

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

response = falcon.GetIntegrations(integration_type=integer, 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

Responses

{
  "integrations": [
    {
      "data": "string",
      "enabled": false,
      "id": 0,
      "integration_type": {},
      "name": "string",
      "node": {},
      "type": {},
      "update_time": 0
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationsV2

Get a list of all the integrations

Method GET

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

Scope ASPM Admin: READ

PEP 8 get_integrations_v2

Parameters

integration_type query · integer

Integration type.

category query · string

Integration category.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "integrations": [
    {
      "data": "string",
      "enabled": false,
      "id": 0,
      "integration_type": {},
      "name": "string",
      "node": {},
      "type": {},
      "update_time": 0
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationTasks

Get all the integration tasks

Method GET

Route /aspm-api-gateway/api/v1/integration_tasks

Scope ASPM Read-Only: READ

PEP 8 get_integration_tasks

Parameters

integration_task_type query · integer

Integration task type.

category query · string

Integration category.

offset query · integer

Starting position to returned records.

limit query · integer

Total number of records to return.

orderBy query · string

Available values (3)

name id integrationTask

direction query · string

Sort direction. Allowed values:

Available values (2)

asc desc

integration_task_types query · integer

Integration task types.

ids query · integer

Integration IDs.

names query · string

Integration names.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "integrationTasks": [
    {
      "accessToken": "string",
      "additionalHeader": "string",
      "businessApplication": "string",
      "data": "string",
      "enabled": false,
      "id": "string",
      "integration": {},
      "integrationTaskType": {},
      "latestTaskRun": {},
      "name": "string",
      "nextRun": {},
      "progress": 0,
      "schedule": {},
      "scheduleEveryUnitDisplayName": "string",
      "trigger": "string",
      "type": {}
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationTasksAdmin

Get all the integration tasks, requires admin scope

Method GET

Route /aspm-api-gateway/api/v1/integration_tasks/admin

Scope ASPM Admin: READ

PEP 8 get_integration_tasks_admin

Parameters

integration_task_type query · integer

Integration task type.

category query · string

Integration task category.

offset query · integer

Offset from which to start returning records.

limit query · integer

Maximum number of records to return.

orderBy query · string

Available values (3)

name id integrationTask

direction query · string

Sort order direction. Allowed values:

Available values (2)

asc desc

integration_task_types query · integer

Integration task types.

ids query · integer

Integration task ID.

names query · string

Integration task name.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "integrationTasks": [
    {
      "accessToken": "string",
      "additionalHeader": "string",
      "businessApplication": "string",
      "data": "string",
      "enabled": false,
      "id": "string",
      "integration": {},
      "integrationTaskType": {},
      "latestTaskRun": {},
      "name": "string",
      "nextRun": {},
      "progress": 0,
      "schedule": {},
      "scheduleEveryUnitDisplayName": "string",
      "trigger": "string",
      "type": {}
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationTasksMetadata

Get metadata about all integration tasks

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 get_integration_tasks_metadata

Parameters

category query · string

Integration category. Allowed values:

Available values (2)

collecting exporting

integration_task_types query · integer

Integration task types.

ids query · integer

Integration IDs.

names query · string

Integration names.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "count": 0,
  "ids": [
    0
  ],
  "integration_task_types": [
    0
  ],
  "names": [
    "string"
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationTasksV2

Get all the integration tasks

Method GET

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

Scope ASPM Admin: READ

PEP 8 get_integration_tasks_v2

Parameters

integration_task_type query · integer

Integration task type.

category query · string

Integration category.

offset query · integer

Starting position to returned records.

limit query · integer

Total number of records to return.

orderBy query · string

Available values (3)

name id integrationTask

direction query · string

Sort direction. Allowed values:

Available values (2)

asc desc

integration_task_types query · integer

Integration task types.

ids query · integer

Integration IDs.

names query · string

Integration names.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "integrationTasks": [
    {
      "accessToken": "string",
      "additionalHeader": "string",
      "businessApplication": "string",
      "data": "string",
      "enabled": false,
      "id": "string",
      "integration": {},
      "integrationTaskType": {},
      "latestTaskRun": {},
      "name": "string",
      "nextRun": {},
      "progress": 0,
      "schedule": {},
      "scheduleEveryUnitDisplayName": "string",
      "trigger": "string",
      "type": {}
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetIntegrationTypes

Get all the integration types

Method GET

Route /aspm-api-gateway/api/v1/integration_types

Scope ASPM Admin: READ

PEP 8 get_integration_types

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

Responses

{
  "types": [
    {
      "configured": false,
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string"
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

getServiceArtifacts

Method GET

Route /aspm-api-gateway/api/v1/artifacts

Scope ASPM Read-Only: READ

PEP 8 get_service_artifacts

Parameters

persistentSignature query · string

optionalTime query · integer

revisionId query · integer

limit query · integer

Upper bound for records returned.

offset query · integer

Starting position for records returned.

orderBy query · string or list of strings

Available values (4)

`artifact_id`	`artifact_name`	`artifact_hash`
`artifact_full_path`

direction query · string

Sort order direction. Available values:

Available values (2)

asc desc

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "artifacts": [
    {
      "fullPath": "string",
      "hash": "string",
      "id": 0,
      "name": "string"
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetServicesCount

Get the total amount of existing services

Method POST

Route /aspm-api-gateway/api/v1/services/count

Scope ASPM Read-Only: READ

PEP 8 get_services_count

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

cids body · array

deployment_tuple_filters body · array

deploymentTupleFilters body · array

DeploymentTupleFilters body · array

nesting_level body · integer

nestingLevel body · integer

NestingLevel body · integer

only_count body · boolean

onlyCount body · boolean

OnlyCount body · boolean

optional_time body · integer

optionalTime body · integer

OptionalTime body · integer

pagination body · object

persistent_signatures body · array

persistentSignatures body · array

PersistentSignatures body · array

ql_filters body · string

qlFilters body · string

QlFilters body · string

related_entities body · array

relatedEntities body · array

RelatedEntities body · array

revision_id body · integer

revisionId body · integer

RevisionId body · integer

roles_signature body · string

rolesSignature body · string

RolesSignature body · string

nesting body · string

level —

roles_signatures body · string

Code Examples

from falconpy import ASPM

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

pagination = {
    "direction": "string",
    "limit": "integer",
    "offset": "integer",
    "order_by": [
        "string"
    ]
}

response = falcon.get_services_count(deployment_tuple_filters="string",
                                     nesting="string",
                                     only_count="string",
                                     optional_time="string",
                                     pagination=pagination,
                                     persistent_signatures="string",
                                     ql_filters="string",
                                     related_entities="string",
                                     revision_id="string",
                                     roles_signatures="string")
print(response)

from falconpy import ASPM

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

pagination = {
    "direction": "string",
    "limit": "integer",
    "offset": "integer",
    "order_by": [
        "string"
    ]
}

response = falcon.GetServicesCount(deployment_tuple_filters="string",
                                   nesting="string",
                                   only_count="string",
                                   optional_time="string",
                                   pagination=pagination,
                                   persistent_signatures="string",
                                   ql_filters="string",
                                   related_entities="string",
                                   revision_id="string",
                                   roles_signatures="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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetServiceViolationTypes

Get the different types of violation

Method GET

Route /aspm-api-gateway/api/v1/services/violations/types

Scope ASPM Read-Only: READ

PEP 8 get_service_violation_types

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

filter body · object

Query filter.

optional_time body · integer

optionalTime body · integer

OptionalTime body · integer

revision_id body · integer

Revision ID.

revisionId body · integer

Revision ID.

RevisionId body · integer

Revision ID.

Code Examples

from falconpy import ASPM

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

filter = {
    "order_by": {
        "by_field": "string",
        "direction": "integer"
    },
    "paginate": {
        "direction": "string",
        "limit": "integer",
        "offset": "integer",
        "orderBy": [
            "string"
        ]
    }
}

response = falcon.get_service_violation_types(filter=filter,
                                              optional_time=integer,
                                              revision_id=integer)
print(response)

from falconpy import ASPM

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

filter = {
    "order_by": {
        "by_field": "string",
        "direction": "integer"
    },
    "paginate": {
        "direction": "string",
        "limit": "integer",
        "offset": "integer",
        "orderBy": [
            "string"
        ]
    }
}

response = falcon.GetServiceViolationTypes(filter=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

Responses

{
  "categories": [
    "string"
  ],
  "violations": [
    "string"
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetTags

Get all the tags

Method GET

Route /aspm-api-gateway/api/v1/tags

Scope ASPM Read-Only: READ

PEP 8 get_tags

Parameters

isUnique query · boolean

tagName query · string

limit query · integer

Total number of tags to return.

offset query · integer

Starting position from which to return records.

name query · string or list of strings

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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_tags(is_unique=boolean,
                           tag_name="string",
                           limit=integer,
                           offset=integer,
                           name=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.GetTags(is_unique=boolean,
                          tag_name="string",
                          limit=integer,
                          offset=integer,
                          name=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("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

Responses

{
  "tags": [
    {
      "automations": [],
      "classifiers": [],
      "isDefault": false,
      "serviceCount": 0,
      "tag": {}
    }
  ],
  "totalCount": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

GetUsersV2

List users

Method GET

Route /aspm-api-gateway/api/v1/users/v2

Scope ASPM Admin: READ

PEP 8 get_users_v2

Parameters

pagination query · string

URL encoded pagination JSON - limit, offset, direction, orderBy

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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);

use rusty_falcon::apis::aspm_api::get_slash_users_slash_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_slash_users_slash_v2(
        &falcon.cfg,  // configuration
        Some("string"),  // pagination
    ).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_users_v2(pagination: 'string')

puts response

Responses

{
  "totalCount": 0,
  "users": [
    {
      "acceptedTerms": false,
      "email": "string",
      "external": false,
      "fullname": "string",
      "groups": [],
      "jobTitle": "string",
      "lastLogin": "string",
      "role": "string",
      "status": "string",
      "userId": 0,
      "username": "string"
    }
  ]
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

PostGroupV2

Create group

Method POST

Route /aspm-api-gateway/api/v1/group/v2

Scope ASPM Falcon Admin: WRITE

PEP 8 post_group_v2

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

children body · array

IDs of child groups.

description body · string

Description of the group.

group_type body · string

Type of the group.

groupType body · string

Type of the group.

GroupType body · string

Type of the group.

is_default body · boolean

Flag indicating if this is the default group.

isDefault body · boolean

Flag indicating if this is the default group.

IsDefault body · boolean

Flag indicating if this is the default group.

name body · string

Name of the group.

parent_id body · integer

ID of the parent group.

parentId body · integer

ID of the parent group.

ParentId body · integer

ID of the parent group.

scope body · string

Scope of the group.

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);

use rusty_falcon::apis::aspm_api::post_slash_group_slash_v2;
use rusty_falcon::easy::client::FalconHandle;
use rusty_falcon::models::TypesCreateGroupRequest;

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

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

    let response = post_slash_group_slash_v2(
        &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::TypesCreateGroupRequest.new(
  children: [],
  description: 'string',
  groupType: 'string',
  isDefault: boolean,
  name: 'string',
  parentId: integer,
  scope: 'string'
)

response = api.post_group_v2(body)

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

RetrieveRelayInstances

Retrieve the relay instances in CSV format

Method GET

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

Scope ASPM Admin: READ

PEP 8 retrieve_relay_instances

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

additional_header body · string

Additional header to provide.

current_aws_arn body · string

Current AWS ARN.

dashboard_url body · string

URL for the related dashboard.

id body · string

ID of the node to remove.

last_health_check body · integer

Last health check.

name body · string

Name.

node_type body · string

Node type.

password body · string

pod_settings body · object

Related pod settings.

proxy_address body · string

Address of the proxy.

status body · object

Current status.

type body · string

Relay type.

use_jobs body · boolean

Flag indicating if jobs should be used.

useJobs body · boolean

Flag indicating if jobs should be used.

UseJobs body · boolean

Flag indicating if jobs should be used.

username body · string

Account username.

ID path · integer

Code Examples

from falconpy import ASPM

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

pod_settings = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "State": "integer",
    "StateLastUpdated": "integer",
    "StateReason": "integer"
}

response = falcon.retrieve_relay_instances(additional_header="string",
                                           current_aws_arn="string",
                                           dashboard_url="string",
                                           id="string",
                                           last_health_check=integer,
                                           name="string",
                                           node_type="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 = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

status = {
    "State": "integer",
    "StateLastUpdated": "integer",
    "StateReason": "integer"
}

response = falcon.RetrieveRelayInstances(additional_header="string",
                                         current_aws_arn="string",
                                         dashboard_url="string",
                                         id="string",
                                         last_health_check=integer,
                                         name="string",
                                         node_type="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("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"
  typeVar := "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: &typeVar,
        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);

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

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

    let response = get_slash_executor_nodes_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket_slash_instances_slash_csv(&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

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.get_executor_nodes_id_09_instances_csv(body, 'string')

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

RunIntegrationTask

Run an integration task by its ID

Method POST

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

Scope ASPM Analyst: WRITE

PEP 8 run_integration_task

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

access_token body · string

Integration access token.

data body · string

Integration task data.

override body · boolean

Override previous task.

scheduled body · boolean

Schedule task.

task_id body · integer

Integration task ID.

ID path · integer

ID of the integration task to execute.

category query · string

Integration task category.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "action_run_id": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

RunIntegrationTaskAdmin

Run an integration task by its ID - for admin scope

Method POST

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

Scope ASPM Admin: WRITE

PEP 8 run_integration_task_admin

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

access_token body · string

data body · string

override body · boolean

scheduled body · boolean

task_id body · integer

ID path · integer

Integration task ID.

category query · string

Integration task category.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "action_run_id": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

RunIntegrationTaskV2

Run an integration task by its ID

Method POST

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

Scope ASPM Admin: WRITE

PEP 8 run_integration_task_v2

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

access_token body · string

data body · string

override body · boolean

scheduled body · boolean

task_id body · integer

ID path · integer

Integration task ID.

category query · string

Integration task category.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "action_run_id": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ServiceNowGetDeployments

Method GET

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

Scope ASPM Read-Only: READ

PEP 8 get_servicenow_deployments

Parameters

ql_filters query · string

Query filter.

limit query · integer

Maximum number of records to return.

offset query · integer

Starting position of return records.

orderBy query · string

Sort order field.

direction query · string

Sort direction.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "deployment_units": [
    {
      "deployments": [],
      "service_id": "string"
    }
  ],
  "error": "string",
  "total_deployments": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

ServiceNowGetServices

Method GET

Route /aspm-api-gateway/api/v1/servicenow/services

Scope ASPM Read-Only: READ

PEP 8 get_servicenow_services

Parameters

ql_filters query · string

Query filter.

exclude_artifacts query · boolean

Flag indicating if artifacts should be excluded.

limit query · integer

Maximum number of records to return.

offset query · integer

Starting position of return records.

orderBy query · string

Sort order field.

direction query · string

Sort direction.

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

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

Responses

{
  "error": "string",
  "services": [
    {
      "ServiceNowService": {},
      "apis": {},
      "artifacts": {},
      "configurations": {},
      "dependencies": {},
      "deployment_units": [],
      "frameworks": {},
      "libraries": {},
      "topics_queues": []
    }
  ],
  "total_services": 0
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

SetCloudSecurityIntegrationState

Set Cloud Security integration state

Method POST

Route /aspm-api-gateway/api/v1/cloud_security_config

Scope ASPM Admin: WRITE

PEP 8 set_cloud_security_integration_state

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

is_enabled body · boolean

Flag indicating if the state should be enabled.

isEnabled body · boolean

Flag indicating if the state should be enabled.

IsEnabled 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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpdateDefaultGroup

Update default group

Method POST

Route /aspm-api-gateway/api/v1/group/{ID}/update_default

Scope ASPM Falcon Admin: WRITE

PEP 8 update_default_group

Parameters

ID path · integer

Group ID

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);

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

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

    let response = post_slash_group_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket_slash_update_default(&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.post_group_id_09_update_default('string')

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpdateExecutorNode

Update an existing relay node

Method PUT

Route /aspm-api-gateway/api/v1/executor_nodes

Scope ASPM Admin: WRITE

PEP 8 update_executor_node

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

additional_header body · string

current_aws_arn body · string

dashboard_url body · string

id body · string

last_health_check body · integer

name body · string

node_type body · string

password body · string

pod_settings body · object

proxy_address body · string

status body · object

type body · string

use_jobs body · boolean

useJobs body · boolean

UseJobs body · boolean

username body · string

Code Examples

from falconpy import ASPM

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

pod_settings = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

response = falcon.update_executor_node(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",
                                       type="string",
                                       use_jobs="string",
                                       username="string")
print(response)

from falconpy import ASPM

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

pod_settings = {
    "imageAddress": "string",
    "imagePullSecrets": [
        "string"
    ],
    "podLabels": [
        {
            "key": "string",
            "value": "string"
        }
    ]
}

response = falcon.UpdateExecutorNode(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",
                                     type="string",
                                     use_jobs="string",
                                     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"
  typeVar := "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: &typeVar,
        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

Responses

{
  "additional_header": "string",
  "current_aws_arn": "string",
  "dashboard_url": "string",
  "id": "string",
  "last_health_check": 0,
  "name": "string",
  "node_type": "string",
  "password": "string",
  "pod_settings": {
    "imageAddress": "string",
    "imagePullSecrets": [],
    "podLabels": []
  },
  "proxy_address": "string",
  "status": {
    "State": 0,
    "StateLastUpdated": 0,
    "StateReason": 0
  },
  "type": "string",
  "useJobs": false,
  "username": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpdateGroup

Update group

Method POST

Route /aspm-api-gateway/api/v1/group/{ID}/v2

Scope ASPM Falcon Admin: WRITE

PEP 8 update_group

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

children body · array

IDs of child groups.

description body · string

Description of the group.

group_id body · integer

groupId body · integer

GroupId body · integer

group_type body · string

Type of the group.

groupType body · string

Type of the group.

GroupType body · string

Type of the group.

is_default body · boolean

Flag indicating if this is the default group.

isDefault body · boolean

Flag indicating if this is the default group.

IsDefault body · boolean

Flag indicating if this is the default group.

name body · string

Name of the group.

parent_id body · integer

ID of the parent group.

parentId body · integer

ID of the parent group.

ParentId body · integer

ID of the parent group.

scope body · string

Scope of the group.

ID path · integer

Group ID

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);

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

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

    let response = post_slash_group_slash_left_curly_bracket_id_left_square_bracket_09_right_square_bracket_plus_right_curly_bracket_slash_v2(&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

body = Falcon::TypesUpdateGroupRequest.new(
  children: [],
  description: 'string',
  groupId: integer,
  groupType: 'string',
  isDefault: boolean,
  name: 'string',
  parentId: integer,
  scope: 'string'
)

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

puts response

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpdateIntegration

Update an existing integration by its ID

Method PUT

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

Scope ASPM Admin: WRITE

PEP 8 update_integration

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

integration body · object

Integration details.

overwrite_fields body · array

Fields to overwrite.

overwriteFields body · array

Fields to overwrite.

OverwriteFields body · array

Fields to overwrite.

ID path · integer

Code Examples

from falconpy import ASPM

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

integration = {
    "data": "string",
    "enabled": "boolean",
    "id": "integer",
    "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": "integer",
        "last_health_check": "integer",
        "name": "string",
        "node_type": "string",
        "password": "string",
        "pod_settings": {
            "imageAddress": "string",
            "imagePullSecrets": [
                "string"
            ],
            "podLabels": [
                {
                    "key": "string",
                    "value": "string"
                }
            ]
        },
        "proxy_address": "string",
        "type": "string",
        "useJobs": "boolean",
        "username": "string"
    },
    "type": {
        "configured": "boolean",
        "display_name": "string",
        "enabled": "boolean",
        "id": "integer",
        "name": "string"
    },
    "update_time": "integer"
}

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

from falconpy import ASPM

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

integration = {
    "data": "string",
    "enabled": "boolean",
    "id": "integer",
    "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": "integer",
        "last_health_check": "integer",
        "name": "string",
        "node_type": "string",
        "password": "string",
        "pod_settings": {
            "imageAddress": "string",
            "imagePullSecrets": [
                "string"
            ],
            "podLabels": [
                {
                    "key": "string",
                    "value": "string"
                }
            ]
        },
        "proxy_address": "string",
        "type": "string",
        "useJobs": "boolean",
        "username": "string"
    },
    "type": {
        "configured": "boolean",
        "display_name": "string",
        "enabled": "boolean",
        "id": "integer",
        "name": "string"
    },
    "update_time": "integer"
}

response = falcon.UpdateIntegration(id=integer,
                                    integration=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

Responses

{
  "integration": {
    "data": "string",
    "enabled": false,
    "id": "string",
    "integration_type": {
      "configured": false,
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string"
    },
    "name": "string",
    "node": {
      "additional_header": "string",
      "current_aws_arn": "string",
      "dashboard_url": "string",
      "id": "string",
      "last_health_check": 0,
      "name": "string",
      "node_type": "string",
      "password": "string",
      "pod_settings": {},
      "proxy_address": "string",
      "status": {},
      "type": "string",
      "useJobs": false,
      "username": "string"
    },
    "type": {
      "configured": false,
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string"
    },
    "update_time": 0
  },
  "new_executor_node": {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": 0,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
      "imageAddress": "string",
      "imagePullSecrets": [],
      "podLabels": []
    },
    "proxy_address": "string",
    "status": {
      "State": 0,
      "StateLastUpdated": 0,
      "StateReason": 0
    },
    "type": "string",
    "useJobs": false,
    "username": "string"
  }
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpdateIntegrationTask

Update an existing integration task by its ID

Method PUT

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

Scope ASPM Admin: WRITE

PEP 8 update_integration_task

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

integration_task body · object

ID path · integer

ID of the integration task to update.

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

Responses

{
  "integrationTask": {
    "accessToken": "string",
    "additionalHeader": "string",
    "businessApplication": "string",
    "data": "string",
    "enabled": false,
    "id": "string",
    "integration": {
      "data": "string",
      "enabled": false,
      "id": "string",
      "integration_type": {},
      "name": "string",
      "node": {},
      "type": {},
      "update_time": 0
    },
    "integrationTaskType": {
      "category": "string",
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string",
      "required_integration_types": []
    },
    "latestTaskRun": {
      "createTime": "string",
      "events": [],
      "id": "string",
      "latestEvent": {},
      "metadata": {},
      "progress": 0,
      "scheduled": false,
      "traceUuid": "string"
    },
    "name": "string",
    "nextRun": {
      "nanos": 0,
      "seconds": 0
    },
    "progress": 0,
    "schedule": {
      "every": 0,
      "every_unit": 0,
      "hour": 0,
      "minute": 0,
      "startTimeTimezoneOffsetMinutes": 0,
      "start_time": {},
      "timezone": 0,
      "weekdays": []
    },
    "scheduleEveryUnitDisplayName": "string",
    "trigger": "string",
    "type": {
      "category": "string",
      "display_name": "string",
      "enabled": false,
      "id": 0,
      "name": "string",
      "required_integration_types": []
    }
  },
  "newExecutorNode": {
    "additional_header": "string",
    "current_aws_arn": "string",
    "dashboard_url": "string",
    "id": "string",
    "last_health_check": 0,
    "name": "string",
    "node_type": "string",
    "password": "string",
    "pod_settings": {
      "imageAddress": "string",
      "imagePullSecrets": [],
      "podLabels": []
    },
    "proxy_address": "string",
    "status": {
      "State": 0,
      "StateLastUpdated": 0,
      "StateReason": 0
    },
    "type": "string",
    "useJobs": false,
    "username": "string"
  }
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpsertBusinessApplications

Create or Update Business Applications

Method PUT

Route /aspm-api-gateway/api/v1/business_applications

Scope ASPM Analyst: WRITE

PEP 8 update_business_applications

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

name body · string

Application name.

persistent_signatures body · array

Signatures.

persistentSignatures body · array

Signatures.

PersistentSignatures body · array

Signatures.

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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

UpsertTags

Create new or update existing tag.

Method PUT

Route /aspm-api-gateway/api/v1/tags

Scope ASPM Analyst: WRITE

PEP 8 update_tags

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

entries body · array

Tag entries. Overrides the is_sensitive, persistent_signature, and value keywords.

is_sensitive body · boolean

Sensitive.

name body · string

Tag name.

tag_type body · string

Tag type.

value body · string

Tag value.

Code Examples

from falconpy import ASPM

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

response = falcon.update_tags(entries=["string"],
                              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
              )

response = falcon.UpsertTags(entries=["string"],
                             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

Responses

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "error": "string",
  "reason": "string"
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

{
  "error": "string",
  "reason": "string"
}

ASPM

Table of Contents

CreateExecutorNode

Parameters

CreateIntegration

Parameters

CreateIntegrationTask

Parameters

DeleteExecutorNode

Parameters

DeleteGroup

Parameters

DeleteIntegration

Parameters

DeleteIntegrationTask

Parameters

DeleteTags

Parameters

ExecuteFunctionData

Parameters

ExecuteFunctionDataCount

Parameters

ExecuteFunctionDataQuery

Parameters

ExecuteFunctionDataQueryCount

Parameters

ExecuteFunctions

Parameters

ExecuteFunctionsCount

Parameters

ExecuteFunctionsOvertime

Parameters

ExecuteFunctionsQuery

Parameters

ExecuteFunctionsQueryCount

Parameters

ExecuteFunctionsQueryOvertime

Parameters

ExecuteQuery

Parameters

GetCloudSecurityIntegrationState

GetExecutorNodes

Parameters

GetExecutorNodesMetadata

Parameters

GetGroupHierarchy

GetGroupsV2

Parameters

GetGroupV2

Parameters

GetIntegrations

Parameters

GetIntegrationsV2

Parameters

GetIntegrationTasks

Parameters

GetIntegrationTasksAdmin

Parameters

GetIntegrationTasksMetadata

Parameters

GetIntegrationTasksV2

Parameters

GetIntegrationTypes

getServiceArtifacts

Parameters

GetServicesCount

Parameters

GetServiceViolationTypes

Parameters

GetTags

Parameters

GetUsersV2

Parameters

PostGroupV2

Parameters

RetrieveRelayInstances

Parameters

RunIntegrationTask

Parameters

RunIntegrationTaskAdmin