List manual cost distribution policies

1 min

GET

https://app.amberflo.io/business-unit/focus-allocation/manual

Retrieves paginated list of manual FOCUS allocation policies that distribute cloud costs to business units using fixed percentages. Manual policies override automatic rules and provide direct control over cost assignment for specific cloud services.

Required parameters:

None - returns all accessible manual allocation policies

Optional parameters:

limit: Controls pagination page size for large policy sets
page: Specifies which page of results to return
providers: Filters policies by cloud providers (AWS, AZURE, GOOGLE_CLOUD)
services: Filters policies by specific cloud services
timeInSeconds: Filters policies active at specific point in time
startTimeInSeconds: Filters policies active after specified time (inclusive)
endTimeInSeconds: Filters policies active before specified time (exclusive)

Returns paginated manual allocation policies including provider context, service scope, distribution rules, and time periods. Use time filters to find policies that were active during specific periods for historical cost analysis.

Query Parameters

limitinteger<int32>
Description
Maximum number of manual allocation policy records to return per page. Controls pagination size for efficient data retrieval.
pageinteger<int32>
Description
Zero-based page number for pagination navigation. Used with limit parameter to access manual allocation policy result pages.
providersstring[]
Description
Cloud provider filter for manual allocation policies. Limits results to specific provider cost allocation rules.
servicesstring[]
Description
Cloud service filter for manual allocation policies. Limits results to specific service cost distribution configurations.
timeInSecondsinteger<int64>
Description
Filter for manual allocation policies active at specific point in time, in Unix timestamp seconds format.
startTimeInSecondsinteger<int64>
Description
Filter for manual allocation policies active after this inclusive time boundary, in Unix timestamp seconds format.
endTimeInSecondsinteger<int64>
Description
Filter for manual allocation policies active before this exclusive time boundary, in Unix timestamp seconds format.

Responses

200Successful request

business_unit.focus_allocation.manual.query.ManualFocusAllocationPolicyPage.out
Description
Paginated response containing manual FOCUS allocation policies with metadata for navigating large policy collections and filtering results.
- metadatabusiness_unit.focus_allocation.manual.query.ManualFocusAllocationPolicyPageMetadata.out
  Description
  Pagination control metadata including page size, current position, filters applied, and total result counts for manual allocation policies.
  - limitinteger<int32>
    Description
    Maximum number of manual allocation policy records per page. Controls pagination size for efficient data retrieval and display.
  - pageinteger<int32>
    Description
    Zero-based current page number in manual allocation policy results. Used for pagination navigation through large policy collections.
  - providersfocus.common.FocusProvider.out[]
    Description
    Applied cloud provider filter for manual allocation policies. Shows which providers are included in current result set.
  - servicesstring[]
    Description
    Applied cloud service filter for manual allocation policies. Shows which services are included in current result set.
  - timeInSecondsinteger<int64>
    Description
    Applied time filter for policies active at specific point. Shows Unix timestamp used for policy activity filtering.
  - startTimeInSecondsinteger<int64>
    Description
    Applied inclusive start time boundary for policy activity filtering. Shows earliest time used in query range.
  - endTimeInSecondsinteger<int64>
    Description
    Applied exclusive end time boundary for policy activity filtering. Shows latest time used in query range.
  - totalRowCountinteger<int32>
    Description
    Total number of manual allocation policies across all pages. Represents complete result set size without pagination.
  - filteredRowCountinteger<int32>
    Description
    Number of manual allocation policies matching applied filters. Represents filtered result set size before pagination.
  - totalFilteredPagesinteger<int32>
    Description
    Total pages available for filtered manual allocation policy results. Used for pagination controls and navigation.
- itemsbusiness_unit.focus_allocation.manual.ManualFocusAllocationPolicy.out[]
  Description
  Array of manual allocation policy configurations for current page. Contains complete policy definitions with distribution rules and timestamps.
  - providerfocus.common.FocusProvider.outrequired
    Description
    Cloud provider for cost allocation policy. Supported values include AWS, AZURE, GOOGLE_CLOUD for targeted service cost distribution.
  - servicestringrequired
    Description
    Specific cloud service name for cost allocation scope. Defines service boundaries for manual percentage-based cost distribution rules.
  - policybusiness_unit.focus_allocation.manual.rules.SimpleDistributionRule.outrequired
    Description
    Distribution rule containing business unit allocation percentages. Defines how costs are divided among business units using fixed ratios.
    - typestringrequired
      Description
      Rule type identifier for simple distribution logic. Always set to 'simple_distribution' for percentage-based cost allocation rules.
      Default
      simple_distribution
    - allocationsmap<string, number>required
      Description
      Map of business unit IDs to allocation percentages. Keys are business unit identifiers, values are decimal percentages totaling 100.0.
  - startTimeInSecondsinteger<int64>required
    Description
    Policy activation timestamp in Unix seconds format. Defines when manual allocation rule begins applying to cloud service costs.
  - endTimeInSecondsinteger<int64>
    Description
    Policy expiration timestamp in Unix seconds format. Optional end time for time-bounded manual allocation rule application periods.
  - createTimeInMillisinteger<int64>
    Description
    Policy creation timestamp in Unix milliseconds format. Tracks when manual allocation policy was first established in system.
  - updateTimeInMillisinteger<int64>
    Description
    Policy modification timestamp in Unix milliseconds format. Tracks when manual allocation policy configuration was last changed.

curl

curl --request GET \
     --url https://app.amberflo.io/business-unit/focus-allocation/manual \
     --header 'accept: application/json'

javascript

var myHeaders = new Headers();
myHeaders.append("accept", "application/json");
myHeaders.append("content-type", "application/json");

var requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://app.amberflo.io/business-unit/focus-allocation/manual", requestOptions)
   .then(response => response.text())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

ruby

require "uri"
require "json"
require "net/http"

url = URI("https://app.amberflo.io/business-unit/focus-allocation/manual")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = "application/json"
request["content-type"] = "application/json"

response = https.request(request)
puts response.read_body

python

import requests
import json

url = "https://app.amberflo.io/business-unit/focus-allocation/manual"

payload = {}
headers = {
   'accept': 'application/json',
   'content-type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

200

// Successful request
{
  "metadata": {
    "limit": "",
    "page": "",
    "providers": [
      ""
    ],
    "services": [
      ""
    ],
    "timeInSeconds": "",
    "startTimeInSeconds": "",
    "endTimeInSeconds": "",
    "totalRowCount": "",
    "filteredRowCount": "",
    "totalFilteredPages": ""
  },
  "items": [
    {
      "provider": "",
      "service": "",
      "policy": {
        "type": "",
        "allocations": ""
      },
      "startTimeInSeconds": "",
      "endTimeInSeconds": "",
      "createTimeInMillis": "",
      "updateTimeInMillis": ""
    }
  ]
}