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.4.9
PowerShell	v2.2.9
Go	v0.20.0
TypeScript	v0.6.0
Rust	v0.7.0
Ruby	v1.2.0

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

ListCollections

List available collection names in alphabetical order.

GET /customobjects/v1/collections

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 list_collections

Parameters

Name	Type	Data type	Description
end	query	string	The end key to end listing to.
limit	query	integer	The limit of results to return.
parameters	query	dictionary	Full query string parameters payload in JSON format.
start	query	string	The start key to start listing from.

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

DescribeCollections

Fetch metadata about one or more existing collections.

PUT /customobjects/v1/collections

Scope Custom Storage: READ Consumes · Produces application/octet-stream application/json

PEP 8 describe_collections

Parameters

Name	Type	Data type	Description
names	query	array (string)	A set of collection names.
parameters	query	dictionary	Full query string parameters payload in JSON format.

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

DescribeCollection

Fetch metadata about an existing collection.

GET /customobjects/v1/collections/{collection_name}

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 describe_collection

Parameters

Name	Type	Data type	Description
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

ListObjects

List the object keys in the specified collection in alphabetical order

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 list

Parameters

Name	Type	Data type	Description
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
parameters	query	dictionary	Full query string parameters payload in JSON format.
start	query	string	The start key to start listing from

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

SearchObjects

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

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

Scope Custom Storage: READ Consumes · Produces application/octet-stream application/json

PEP 8 search

Parameters

Name	Type	Data type	Description
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
parameters	query	dictionary	Full query string parameters payload in JSON format.
sort	query	string	The sort order for the returned results.

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

GetObject

Get the bytes for the specified object

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

Scope Custom Storage: READ Consumes · Produces application/json application/octet-stream

PEP 8 get

Parameters

Name	Type	Data type	Description
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

PutObject

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

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

Scope Custom Storage: WRITE Consumes · Produces application/octet-stream application/json

PEP 8 upload

Parameters

Name	Type	Data type	Description
body	body	string	The object to be uploaded in binary format.
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.
schema_version	query	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(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

DeleteObject

Delete the specified object

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

Scope Custom Storage: WRITE Consumes · Produces application/json

PEP 8 delete

Parameters

Name	Type	Data type	Description
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.

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

GetObjectMetadata

Get the metadata for the specified object

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 metadata

Parameters

Name	Type	Data type	Description
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

ListSchemas

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

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 list_schemas

Parameters

Name	Type	Data type	Description
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.
parameters	query	dictionary	Full query string parameters payload in JSON format.
start	query	string	The start key to start listing from.

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

GetSchema

Get the bytes of the specified schema of the requested collection.

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

Scope Custom Storage: READ Consumes · Produces application/json application/octet-stream

PEP 8 get_schema

Parameters

Name	Type	Data type	Description
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

GetSchemaMetadata

Get the metadata for the specified schema of the requested collection.

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 schema_metadata

Parameters

Name	Type	Data type	Description
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

ListObjectsByVersion

List the object keys in the specified collection in alphabetical order

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 list_by_version

Parameters

Name	Type	Data type	Description
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
parameters	query	dictionary	Full query string parameters payload in JSON format.
start	query	string	The start key to start listing from

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

SearchObjectsByVersion

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

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

Scope Custom Storage: READ Consumes · Produces application/octet-stream application/json

PEP 8 search_by_version

Parameters

Name	Type	Data type	Description
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
parameters	query	dictionary	Full query string parameters payload in JSON format.
sort	query	string	The sort order for the returned results.

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

GetVersionedObject

Get the bytes for the specified object

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

Scope Custom Storage: READ Consumes · Produces application/json application/octet-stream

PEP 8 get_version

Parameters

Name	Type	Data type	Description
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

PutObjectByVersion

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

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

Scope Custom Storage: WRITE Consumes · Produces application/octet-stream application/json

PEP 8 upload_version

Parameters

Name	Type	Data type	Description
body	body	string	The object to be uploaded in binary format.
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.
schema_version	query	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")
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")
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

DeleteVersionedObject

Delete the specified versioned object

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

Scope Custom Storage: WRITE Consumes · Produces application/json

PEP 8 delete_version

Parameters

Name	Type	Data type	Description
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.

Code Examples

from falconpy import CustomStorage

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

response = falcon.delete_version(collection_name="string",
                                 collection_version="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_version="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

GetVersionedObjectMetadata

Get the metadata for the specified object

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

Scope Custom Storage: READ Consumes · Produces application/json

PEP 8 version_metadata

Parameters

Name	Type	Data type	Description
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

Custom Storage

Table of Contents

ListCollections

Parameters

Code Examples

DescribeCollections

Parameters

Code Examples

DescribeCollection

Parameters

Code Examples

ListObjects

Parameters

Code Examples

SearchObjects

Parameters

Code Examples

GetObject

Parameters

Code Examples

PutObject

Parameters

Code Examples

DeleteObject

Parameters

Code Examples

GetObjectMetadata

Parameters

Code Examples

ListSchemas

Parameters

Code Examples

GetSchema

Parameters

Code Examples

GetSchemaMetadata

Parameters

Code Examples

ListObjectsByVersion

Parameters

Code Examples

SearchObjectsByVersion

Parameters

Code Examples

GetVersionedObject

Parameters

Code Examples

PutObjectByVersion

Parameters

Code Examples

DeleteVersionedObject

Parameters

Code Examples

GetVersionedObjectMetadata

Parameters

Code Examples