Custom Storage

The Custom Storage service collection provides operations for managing custom object storage within the CrowdStrike platform. List, describe, search, get, upload, and delete objects within named collections. Support includes versioned collections with schema management and metadata retrieval.

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
DeleteObject `delete`	Delete the specified object
DeleteVersionedObject `delete_version`	Delete the specified versioned object
DescribeCollection `describe_collection`	Fetch metadata about an existing collection
DescribeCollections `describe_collections`	Fetch metadata about one or more existing collections
GetObject `get`	Get the bytes for the specified object
GetObjectMetadata `metadata`	Get the metadata for the specified object
GetSchema `get_schema`	Get the bytes of the specified schema of the requested collection
GetSchemaMetadata `schema_metadata`	Get the metadata for the specified schema of the requested collection
GetVersionedObject `get_version`	Get the bytes for the specified object
GetVersionedObjectMetadata `version_metadata`	Get the metadata for the specified object
ListCollections `list_collections`	List available collection names in alphabetical order
ListObjects `list`	List the object keys in the specified collection in alphabetical order
ListObjectsByVersion `list_by_version`	List the object keys in the specified collection in alphabetical order
ListSchemas `list_schemas`	Get the list of schemas for the requested collection in reverse version order (latest first)
PutObject `upload`	Put the specified new object at the given key or overwrite an existing object at the given key
PutObjectByVersion `upload_version`	Put the specified new object at the given key or overwrite an existing object at the given key
SearchObjects `search`	Search for objects that match the specified filter criteria (returns metadata, not actual objects)
SearchObjectsByVersion `search_by_version`	Search for objects that match the specified filter criteria (returns metadata, not actual objects)

DeleteObject

Delete the specified object

Method DELETE

Route /customobjects/v1/collections/{collection_name}/objects/{object_key}

Scope Custom storage: WRITE

PEP 8 delete

Parameters

collection_name path · string

The name of the collection

dry_run query · boolean

If false, run the operation as normal. If true, validate that the request *would* succeed, but don’t execute it.

object_key path · string

The object key

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.delete(collection_name="string",
                         dry_run=boolean,
                         object_key="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.DeleteObject(collection_name="string",
                               dry_run=boolean,
                               object_key="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("DeleteObject",
                          collection_name="string",
                          dry_run=boolean,
                          object_key="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.DeleteObject(
    &custom_storage.DeleteObjectParams{
      CollectionName: "string",
      DryRun: boolean,
      ObjectKey: "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.customStorage._delete(
  "string",  // collectionName
  "string",  // objectKey
  boolean  // dryRun
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::delete_object;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = delete_object(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // object_key
        Some(boolean),  // dry_run
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

DeleteVersionedObject

Delete the specified versioned object

Method DELETE

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects/{object_key}

Scope Custom storage: WRITE

PEP 8 delete_version

Parameters

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

dry_run query · boolean

If false, run the operation as normal. If true, validate that the request *would* succeed, but don’t execute it.

object_key path · string

The object key

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.delete_version(collection_name="string",
                                 collection_name="string",
                                 dry_run=boolean,
                                 object_key="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.DeleteVersionedObject(collection_name="string",
                                        collection_name="string",
                                        dry_run=boolean,
                                        object_key="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("DeleteVersionedObject",
                          collection_name="string",
                          collection_version="string",
                          dry_run=boolean,
                          object_key="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.DeleteVersionedObject(
    &custom_storage.DeleteVersionedObjectParams{
      CollectionName: "string",
      CollectionVersion: "string",
      DryRun: boolean,
      ObjectKey: "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.customStorage.deleteVersionedObject(
  "string",  // collectionName
  "string",  // collectionVersion
  "string",  // objectKey
  boolean  // dryRun
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::delete_versioned_object;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = delete_versioned_object(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        "string",  // object_key
        Some(boolean),  // dry_run
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

DescribeCollection

Fetch metadata about an existing collection

Method GET

Route /customobjects/v1/collections/{collection_name}

Scope Custom storage: READ

PEP 8 describe_collection

Parameters

collection_name path · string

The name of the collection

Code Examples

from falconpy import CustomStorage

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

response = falcon.describe_collection(collection_name="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.DescribeCollection(collection_name="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("DescribeCollection",
                          collection_name="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.DescribeCollection(
    &custom_storage.DescribeCollectionParams{
      CollectionName: "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.customStorage.describeCollection("string");  // collectionName

console.log(response);

use rusty_falcon::apis::custom_storage_api::describe_collection;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = describe_collection(
        &falcon.cfg,  // configuration
        "string",  // collection_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::CustomStorage.new

response = api.describe_collection('string')

puts response

Responses

[
  {
    "agent_tools_meta": {},
    "created_by": {},
    "created_timestamp": "string",
    "description": "string",
    "draft_schema_version": "string",
    "is_global": false,
    "last_modified_by": {},
    "last_modified_timestamp": "string",
    "name": "string",
    "namespace": "string",
    "permissions": [],
    "published_version": "string",
    "schema_version": "string",
    "status": "string",
    "version": "string",
    "workflow_meta": {}
  }
]

{
  "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
    }
  }
}

{
  "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
    }
  }
}

DescribeCollections

Fetch metadata about one or more existing collections

Method PUT

Route /customobjects/v1/collections

Scope Custom storage: READ

PEP 8 describe_collections

Parameters

names query · string or list of strings

A set of collection names

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

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

response = falcon.describe_collections(names=id_list)
print(response)

from falconpy import CustomStorage

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

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

response = falcon.DescribeCollections(names=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("DescribeCollections",
                          names=id_list)
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.DescribeCollections(
    &custom_storage.DescribeCollectionsParams{
      Names: []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.customStorage.describeCollections(["ID1", "ID2", "ID3"]);  // names

console.log(response);

use rusty_falcon::apis::custom_storage_api::describe_collections;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = describe_collections(
        &falcon.cfg,  // configuration
        vec!["string".to_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::CustomStorage.new

response = api.describe_collections(['ID1', 'ID2', 'ID3'])

puts response

Responses

[
  {
    "agent_tools_meta": {},
    "created_by": {},
    "created_timestamp": "string",
    "description": "string",
    "draft_schema_version": "string",
    "is_global": false,
    "last_modified_by": {},
    "last_modified_timestamp": "string",
    "name": "string",
    "namespace": "string",
    "permissions": [],
    "published_version": "string",
    "schema_version": "string",
    "status": "string",
    "version": "string",
    "workflow_meta": {}
  }
]

{
  "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
    }
  }
}

{
  "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
    }
  }
}

GetObject

Get the bytes for the specified object

Method GET

Route /customobjects/v1/collections/{collection_name}/objects/{object_key}

Scope Custom storage: READ

PEP 8 get

Parameters

collection_name path · string

The name of the collection

object_key path · string

The object key

Code Examples

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.get(collection_name="string",
                          object_key="string",
                          stream=boolean)
    save_file.write(response)

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.GetObject(collection_name="string",
                                object_key="string",
                                stream=boolean)
    save_file.write(response)

from falconpy import APIHarnessV2

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

with open("output_file", "wb") as save_file:
    response = falcon.command("GetObject",
                              collection_name="string",
                              object_key="string")
    save_file.write(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetObject(
    &custom_storage.GetObjectParams{
      CollectionName: "string",
      ObjectKey: "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.customStorage.get(
  "string",  // collectionName
  "string"  // objectKey
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_object;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = get_object(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // object_key
    ).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::CustomStorage.new

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

puts response

Responses

{
  "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
    }
  }
}

{
  "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
    }
  }
}

GetObjectMetadata

Get the metadata for the specified object

Method GET

Route /customobjects/v1/collections/{collection_name}/objects/{object_key}/metadata

Scope Custom storage: READ

PEP 8 metadata

Parameters

collection_name path · string

The name of the collection

object_key path · string

The object key

Code Examples

from falconpy import CustomStorage

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

response = falcon.metadata(collection_name="string", object_key="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.GetObjectMetadata(collection_name="string",
                                    object_key="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("GetObjectMetadata",
                          collection_name="string",
                          object_key="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetObjectMetadata(
    &custom_storage.GetObjectMetadataParams{
      CollectionName: "string",
      ObjectKey: "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.customStorage.metadata(
  "string",  // collectionName
  "string"  // objectKey
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_object_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_object_metadata(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // object_key
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

GetSchema

Get the bytes of the specified schema of the requested collection

Method GET

Route /customobjects/v1/collections/{collection_name}/schemas/{schema_version}

Scope Custom storage: READ

PEP 8 get_schema

Parameters

collection_name path · string

The name of the collection

schema_version path · string

The version of the collection schema or ‘latest’ for the latest version

Code Examples

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.get_schema(collection_name="string",
                                 schema_version="string",
                                 stream=boolean)
    save_file.write(response)

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.GetSchema(collection_name="string",
                                schema_version="string",
                                stream=boolean)
    save_file.write(response)

from falconpy import APIHarnessV2

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

with open("output_file", "wb") as save_file:
    response = falcon.command("GetSchema",
                              collection_name="string",
                              schema_version="string")
    save_file.write(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetSchema(
    &custom_storage.GetSchemaParams{
      CollectionName: "string",
      SchemaVersion: "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.customStorage.getSchema(
  "string",  // collectionName
  "string"  // schemaVersion
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_schema;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = get_schema(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // schema_version
    ).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::CustomStorage.new

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

puts response

Responses

{
  "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
    }
  }
}

{
  "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
    }
  }
}

GetSchemaMetadata

Get the metadata for the specified schema of the requested collection

Method GET

Route /customobjects/v1/collections/{collection_name}/schemas/{schema_version}/metadata

Scope Custom storage: READ

PEP 8 schema_metadata

Parameters

collection_name path · string

The name of the collection

schema_version path · string

The version of the collection schema or ‘latest’ for the latest version

Code Examples

from falconpy import CustomStorage

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

response = falcon.schema_metadata(collection_name="string",
                                  schema_version="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.GetSchemaMetadata(collection_name="string",
                                    schema_version="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("GetSchemaMetadata",
                          collection_name="string",
                          schema_version="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetSchemaMetadata(
    &custom_storage.GetSchemaMetadataParams{
      CollectionName: "string",
      SchemaVersion: "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.customStorage.getSchemaMetadata(
  "string",  // collectionName
  "string"  // schemaVersion
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_schema_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_schema_metadata(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // schema_version
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "create_timestamp": "string",
    "created_by": {},
    "indexed_fields": [],
    "last_modified_by": {},
    "last_modified_timestamp": "string",
    "namespace": "string",
    "status": "string",
    "type": "string",
    "version": "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
    }
  }
}

{
  "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
    }
  }
}

GetVersionedObject

Get the bytes for the specified object

Method GET

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects/{object_key}

Scope Custom storage: READ

PEP 8 get_version

Parameters

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

object_key path · string

The object key

Code Examples

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.get_version(collection_name="string",
                                  collection_version="string",
                                  object_key="string",
                                  stream=boolean)
    save_file.write(response)

from falconpy import CustomStorage

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

with open("output_file", "wb") as save_file:
    response = falcon.GetVersionedObject(collection_name="string",
                                         collection_version="string",
                                         object_key="string",
                                         stream=boolean)
    save_file.write(response)

from falconpy import APIHarnessV2

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

with open("output_file", "wb") as save_file:
    response = falcon.command("GetVersionedObject",
                              collection_name="string",
                              collection_version="string",
                              object_key="string")
    save_file.write(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetVersionedObject(
    &custom_storage.GetVersionedObjectParams{
      CollectionName: "string",
      CollectionVersion: "string",
      ObjectKey: "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.customStorage.getVersionedObject(
  "string",  // collectionName
  "string",  // collectionVersion
  "string"  // objectKey
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_versioned_object;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = get_versioned_object(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        "string",  // object_key
    ).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::CustomStorage.new

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

puts response

Responses

{
  "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
    }
  }
}

{
  "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
    }
  }
}

GetVersionedObjectMetadata

Get the metadata for the specified object

Method GET

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects/{object_key}/metadata

Scope Custom storage: READ

PEP 8 version_metadata

Parameters

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

object_key path · string

The object key

Code Examples

from falconpy import CustomStorage

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

response = falcon.version_metadata(collection_name="string",
                                   collection_version="string",
                                   object_key="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.GetVersionedObjectMetadata(collection_name="string",
                                             collection_version="string",
                                             object_key="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("GetVersionedObjectMetadata",
                          collection_name="string",
                          collection_version="string",
                          object_key="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.GetVersionedObjectMetadata(
    &custom_storage.GetVersionedObjectMetadataParams{
      CollectionName: "string",
      CollectionVersion: "string",
      ObjectKey: "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.customStorage.getVersionedObjectMetadata(
  "string",  // collectionName
  "string",  // collectionVersion
  "string"  // objectKey
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::get_versioned_object_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_versioned_object_metadata(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        "string",  // object_key
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

ListCollections

List available collection names in alphabetical order

Method GET

Route /customobjects/v1/collections

Scope Custom storage: READ

PEP 8 list_collections

Parameters

end query · string

The end key to end listing to

limit query · integer

The limit of results to return

start query · string

The start key to start listing from

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.list_collections(end="string", limit=integer, start="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.ListCollections(end="string", limit=integer, start="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("ListCollections",
                          end="string",
                          limit=integer,
                          start="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.ListCollections(
    &custom_storage.ListCollectionsParams{
      End: "string",
      Limit: integer,
      Start: "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.customStorage.listCollections(
  "string",  // end
  integer,  // limit
  "string"  // start
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::list_collections;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = list_collections(
        &falcon.cfg,  // configuration
        Some("string"),  // end
        Some(integer),  // limit
        Some("string"),  // start
    ).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::CustomStorage.new

response = api.list_collections(end: 'string', limit: integer, start: 'string')

puts response

Responses

[
  "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
    }
  }
}

{
  "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
    }
  }
}

ListObjects

List the object keys in the specified collection in alphabetical order

Method GET

Route /customobjects/v1/collections/{collection_name}/objects

Scope Custom storage: READ

PEP 8 list

Parameters

collection_name path · string

The name of the collection

end query · string

The end key to end listing to

limit query · integer

The limit of results to return

start query · string

The start key to start listing from

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.list(collection_name="string",
                       end="string",
                       limit=integer,
                       start="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.ListObjects(collection_name="string",
                              end="string",
                              limit=integer,
                              start="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("ListObjects",
                          collection_name="string",
                          end="string",
                          limit=integer,
                          start="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.ListObjects(
    &custom_storage.ListObjectsParams{
      CollectionName: "string",
      End: "string",
      Limit: integer,
      Start: "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.customStorage.list(
  "string",  // collectionName
  "string",  // end
  integer,  // limit
  "string"  // start
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::list_objects;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = list_objects(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        Some("string"),  // end
        Some(integer),  // limit
        Some("string"),  // start
    ).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::CustomStorage.new

response = api.list_objects('string')

puts response

Responses

[
  "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
    }
  }
}

{
  "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
    }
  }
}

ListObjectsByVersion

List the object keys in the specified collection in alphabetical order

Method GET

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects

Scope Custom storage: READ

PEP 8 list_by_version

Parameters

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

end query · string

The end key to end listing to

limit query · integer

The limit of results to return

start query · string

The start key to start listing from

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.list_by_version(collection_name="string",
                                  collection_version="string",
                                  end="string",
                                  limit=integer,
                                  start="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.ListObjectsByVersion(collection_name="string",
                                       collection_version="string",
                                       end="string",
                                       limit=integer,
                                       start="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("ListObjectsByVersion",
                          collection_name="string",
                          collection_version="string",
                          end="string",
                          limit=integer,
                          start="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.ListObjectsByVersion(
    &custom_storage.ListObjectsByVersionParams{
      CollectionName: "string",
      CollectionVersion: "string",
      End: "string",
      Limit: integer,
      Start: "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.customStorage.listObjectsByVersion(
  "string",  // collectionName
  "string",  // collectionVersion
  "string",  // end
  integer,  // limit
  "string"  // start
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::list_objects_by_version;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = list_objects_by_version(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        Some("string"),  // end
        Some(integer),  // limit
        Some("string"),  // start
    ).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::CustomStorage.new

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

puts response

Responses

[
  "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
    }
  }
}

{
  "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
    }
  }
}

ListSchemas

Get the list of schemas for the requested collection in reverse version order (latest first)

Method GET

Route /customobjects/v1/collections/{collection_name}/schemas

Scope Custom storage: READ

PEP 8 list_schemas

Parameters

collection_name path · string

The name of the collection

end query · string

The end key to end listing to

limit query · integer

The limit of results to return

start query · string

The start key to start listing from

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.list_schemas(collection_name="string",
                               end="string",
                               limit=integer,
                               start="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.ListSchemas(collection_name="string",
                              end="string",
                              limit=integer,
                              start="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("ListSchemas",
                          collection_name="string",
                          end="string",
                          limit=integer,
                          start="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.ListSchemas(
    &custom_storage.ListSchemasParams{
      CollectionName: "string",
      End: "string",
      Limit: integer,
      Start: "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.customStorage.listSchemas(
  "string",  // collectionName
  "string",  // end
  integer,  // limit
  "string"  // start
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::list_schemas;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = list_schemas(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        Some("string"),  // end
        Some(integer),  // limit
        Some("string"),  // start
    ).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::CustomStorage.new

response = api.list_schemas('string')

puts response

Responses

[
  "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
    }
  }
}

{
  "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
    }
  }
}

PutObject

Put the specified new object at the given key or overwrite an existing object at the given key

Method PUT

Route /customobjects/v1/collections/{collection_name}/objects/{object_key}

Scope Custom storage: WRITE

PEP 8 upload

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

collection_name path · string

The name of the collection

dry_run query · boolean

If false, run the operation as normal. If true, validate that the request *would* succeed, but don’t execute it.

object_key path · string

The object key

schema_version query · string

The version of the collection schema

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.upload(collection_name="string",
                         dry_run=boolean,
                         object_key="string",
                         schema_version="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.PutObject(collection_name="string",
                            dry_run=boolean,
                            object_key="string",
                            schema_version="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("PutObject", collection_name="string", dry_run=boolean, object_key="string", schema_version="string", body={})
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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

  schemaVersion := "string"

  response, err := client.CustomStorage.PutObject(
    &custom_storage.PutObjectParams{
      CollectionName: "string",
      DryRun: boolean,
      ObjectKey: "string",
      SchemaVersion: &schemaVersion,
      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.customStorage.upload(
  "string",  // collectionName
  "string",  // objectKey
  {},  // body
  boolean,  // dryRun
  "string"  // schemaVersion
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::put_object;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = put_object(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // object_key
        Default::default(),  // body
        Some(boolean),  // dry_run
        Some("string"),  // schema_version
    ).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::CustomStorage.new

body = Falcon::File.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

PutObjectByVersion

Put the specified new object at the given key or overwrite an existing object at the given key

Method PUT

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects/{object_key}

Scope Custom storage: WRITE

PEP 8 upload_version

Parameters

body body · dictionary

Full body payload as JSON formatted dictionary.

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

dry_run query · boolean

If false, run the operation as normal. If true, validate that the request *would* succeed, but don’t execute it.

object_key path · string

The object key

parameters query · dictionary

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

schema_version body · string

The version of the collection schema.

Code Examples

from falconpy import CustomStorage

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

response = falcon.upload_version(collection_name="string",
                                 collection_version="string",
                                 dry_run=boolean,
                                 object_key="string",
                                 schema_version="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.PutObjectByVersion(collection_name="string",
                                     collection_version="string",
                                     dry_run=boolean,
                                     object_key="string",
                                     schema_version="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("PutObjectByVersion", collection_name="string", collection_version="string", dry_run=boolean, object_key="string", body={})
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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.CustomStorage.PutObjectByVersion(
    &custom_storage.PutObjectByVersionParams{
      CollectionName: "string",
      CollectionVersion: "string",
      DryRun: boolean,
      ObjectKey: "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.customStorage.putObjectByVersion(
  "string",  // collectionName
  "string",  // collectionVersion
  "string",  // objectKey
  {},  // body
  boolean  // dryRun
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::put_object_by_version;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = put_object_by_version(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        "string",  // object_key
        Default::default(),  // body
        Some(boolean),  // dry_run
    ).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::CustomStorage.new

body = Falcon::File.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

SearchObjects

Search for objects that match the specified filter criteria (returns metadata, not actual objects)

Method POST

Route /customobjects/v1/collections/{collection_name}/objects

Scope Custom storage: READ

PEP 8 search

Parameters

collection_name path · string

The name of the collection

filter query · string

The filter to limit the returned results.

limit query · integer

The limit of results to return

offset query · integer

The offset of results to return

sort query · string

The sort order for the returned results.

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.search(collection_name="string",
                         filter="string",
                         limit=integer,
                         offset=integer,
                         sort="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.SearchObjects(collection_name="string",
                                filter="string",
                                limit=integer,
                                offset=integer,
                                sort="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("SearchObjects",
                          collection_name="string",
                          filter="string",
                          limit=integer,
                          offset=integer,
                          sort="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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

  sort := "string"

  response, err := client.CustomStorage.SearchObjects(
    &custom_storage.SearchObjectsParams{
      CollectionName: "string",
      Filter: "string",
      Limit: integer,
      Offset: integer,
      Sort: &sort,
      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.customStorage.search(
  "string",  // collectionName
  "string",  // filter
  integer,  // limit
  integer,  // offset
  "string"  // sort
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::search_objects;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = search_objects(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // filter
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // sort
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

SearchObjectsByVersion

Search for objects that match the specified filter criteria (returns metadata, not actual objects)

Method POST

Route /customobjects/v1/collections/{collection_name}/{collection_version}/objects

Scope Custom storage: READ

PEP 8 search_by_version

Parameters

collection_name path · string

The name of the collection

collection_version path · string

The version of the collection

filter query · string

The filter to limit the returned results.

limit query · integer

The limit of results to return

offset query · integer

The offset of results to return

sort query · string

The sort order for the returned results.

parameters query · dictionary

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

Code Examples

from falconpy import CustomStorage

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

response = falcon.search_by_version(collection_name="string",
                                    collection_version="string",
                                    filter="string",
                                    limit=integer,
                                    offset=integer,
                                    sort="string")
print(response)

from falconpy import CustomStorage

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

response = falcon.SearchObjectsByVersion(collection_name="string",
                                         collection_version="string",
                                         filter="string",
                                         limit=integer,
                                         offset=integer,
                                         sort="string")
print(response)

from falconpy import APIHarnessV2

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

response = falcon.command("SearchObjectsByVersion",
                          collection_name="string",
                          collection_version="string",
                          filter="string",
                          limit=integer,
                          offset=integer,
                          sort="string")
print(response)

package main

import (
  "context"
  "fmt"
  "os"

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

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

  sort := "string"

  response, err := client.CustomStorage.SearchObjectsByVersion(
    &custom_storage.SearchObjectsByVersionParams{
      CollectionName: "string",
      CollectionVersion: "string",
      Filter: "string",
      Limit: integer,
      Offset: integer,
      Sort: &sort,
      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.customStorage.searchObjectsByVersion(
  "string",  // collectionName
  "string",  // collectionVersion
  "string",  // filter
  integer,  // limit
  integer,  // offset
  "string"  // sort
);

console.log(response);

use rusty_falcon::apis::custom_storage_api::search_objects_by_version;
use rusty_falcon::easy::client::FalconHandle;

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

    let response = search_objects_by_version(
        &falcon.cfg,  // configuration
        "string",  // collection_name
        "string",  // collection_version
        "string",  // filter
        Some(integer),  // limit
        Some(integer),  // offset
        Some("string"),  // sort
    ).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::CustomStorage.new

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

puts response

Responses

[
  {
    "collection_name": "string",
    "collection_version": "string",
    "last_modified_time": "string",
    "namespace": "string",
    "object_key": "string",
    "schema_version": "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
    }
  }
}

{
  "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
    }
  }
}

Custom Storage

Table of Contents

DeleteObject

Parameters

DeleteVersionedObject

Parameters

DescribeCollection

Parameters

DescribeCollections

Parameters

GetObject

Parameters

GetObjectMetadata

Parameters

GetSchema

Parameters

GetSchemaMetadata

Parameters

GetVersionedObject

Parameters

GetVersionedObjectMetadata

Parameters

ListCollections

Parameters

ListObjects

Parameters

ListObjectsByVersion

Parameters

ListSchemas

Parameters

PutObject

Parameters

PutObjectByVersion

Parameters

SearchObjects

Parameters

SearchObjectsByVersion

Parameters