Programmatically Understand Your AWS Enterprise Support Charges with the AWS Billing API

If you manage Enterprise Support for a large AWS organization, you’ve likely been asked which accounts a single Support line item comes from and how it was calculated. These are the questions the AWS Billing API can now answer programmatically. This post shows you how to break down your monthly AWS Enterprise Support charge by account using three AWS Billing API operations.

Using the AWS Command Line Interface (AWS CLI), this post shows you how to use three AWS Billing API operations to read your Enterprise Support contract rules, retrieve the finalized monthly charge, and break that charge down by account so you can reconcile and explain it. For related background on how AWS distributes shared charges across a consolidated organization, refer to the AWS consolidated billing process.

Overview of solution

Use the following three question and corresponding API operation, in order, to understand your enterprise support charges.

What are the rules for how my support charge is calculated? get-enterprise-support-contract-details

What’s the total support charge for the month, and how was it derived? get-enterprise-support-charge-summary

How does that total break down by account? list-enterprise-support-linked-account-charges

All three operations take a required --billing-month in YYYY-MM format, and it must be a month in the past (the current month isn’t finalized yet). You call them from your payer (management) account — the account authorized to view Support data for everything in its profile.

Walkthrough

In this walkthrough, you call each of the three operations in turn, learn how to read the output, and then combine the results into a single reconciliation script.

1. Read the contract rules with get-enterprise-support-contract-details
2. Retrieve the monthly total with get-enterprise-support-charge-summary
3. Break the total down per linked account with list-enterprise-support-linked-account-charges

Prerequisites

For this walkthrough, you should have the following prerequisites:

• An AWS account enrolled in Enterprise Support.
• Access to the payer (management) account of the organization whose account is enrolled at AWS Billing API, reach out to your Technical Account Manager (TAM) to enroll your account.
• billing read permissions on the identity you use.
• A recent version of the AWS CLI (these commands live under the aws billing service), and Python 3 with boto3 if you want to run the AWS Solution Support Usage Breakdown script or AWS SDK for Python (Boto3).

A note on formatting: the dollar figures in every response come back as strings, not numbers (for example "totalSupportCharge": "18500.00"). If needed, cast to a decimal type before doing arithmetic.

Step 1: Read the contract rules

Start here, because everything downstream makes more sense once you know how your charge is supposed to be built. For field-level reference, refer to the get-enterprise-support-contract-details documentation.

Use the following command to read your contract rules:

aws billing get-enterprise-support-contract-details \
  --billing-month 2026-07 \
  --output json

A trimmed, sanitized response:

{
  "isContractActive": true,
  "supportAllocationMethod": "Proportional",
  "supportReservedInstanceTreatmentMethod": "Upfront",
  "supportSavingsPlansTreatmentMethod": "Upfront",
  "supportProrateStartDate": "2026-07-01T00:00:00+00:00",
  "contractPayerAccountIds": [
    { "accountId": "111111111111", "isGdn": true },
    { "accountId": "222222222222", "isGdn": true }
  ],
  "chargedPayerAccountIds": [
    { "accountId": "111111111111", "chargePercentage": "0.0" },
    { "accountId": "222222222222", "chargePercentage": "0.0" }
  ],
  "pricingPlans": [
    {
      "description": "Enterprise Support",
      "minimumCharge": "15000.0",
      "tiers": [
        { "tierMinimum": "0.0",       "tierMaximum": "150000.0",  "additionalPercentageOfAggregateCharges": "0.10" },
        { "tierMinimum": "150000.0",  "tierMaximum": "500000.0",  "additionalPercentageOfAggregateCharges": "0.07" },
        { "tierMinimum": "500000.0",  "tierMaximum": "1000000.0", "additionalPercentageOfAggregateCharges": "0.05" },
        { "tierMinimum": "1000000.0", "tierMaximum": "9223372036854776000", "additionalPercentageOfAggregateCharges": "0.03" }
      ]
    }
  ]
}

The fields that matter most day to day:

• supportAllocationMethod – How the total charge is spread across your accounts. Proportional charges each account in proportion to its own eligible spend; Fixed Percentage follows the pre-set split written into your contract.
• chargedPayerAccountIds[].chargePercentage – The per-payer split, and the quickest way to confirm which billing model you’re on. Read the percentages across all your payers together and the pattern tells you the model:
  • Multiple payers, all showing 0.0 → proportional allocation. There’s no fixed split to store because each account is charged in proportion to its own eligible spend.
  • Multiple payers, one showing 100 → consolidated billing: that payer absorbs the entire Support charge for the group.
  • Multiple payers with non-zero values that sum to 100 (e.g., 20 / 30 / 50) → fixed-percentage allocation: each payer carries its contracted share.
• supportReservedInstanceTreatmentMethod / supportSavingsPlansTreatmentMethod – Whether RI and Savings Plan fees count toward support-eligible spend, and how (Upfront, Amortized, and so on). This is why the RI spend appears in the Step 2 total.
• pricingPlans[].tiers – The tiered rate card behind the total. The marginal rate steps down as aggregate spend climbs (10% → 7% → 5% → 3%); together with minimumCharge, these tiers are the formula the charge summary applies.
• supportProrateStartDate – The anchor date for prorating accounts that joined or left mid-month.

Step 2: Retrieve the monthly total

Next, get the aggregate for the whole Support profile and the inputs used to derive it. Refer to the get-enterprise-support-charge-summary documentation for the full field list.

Use the following command to retrieve the monthly total:

aws billing get-enterprise-support-charge-summary \
  --billing-month 2026-07 \
  --output json

A sanitized response:

{
  "payerAccountId": "111111111111",
  "billingMonth": "2026-07",
  "billingPeriodStartDate": "2026-07-01T00:00:00+00:00",
  "billingPeriodEndDate": "2026-07-31T23:59:59+00:00",
  "isEstimated": false,
  "billDate": "2026-08-03T00:00:00+00:00",
  "totalSupportEligibleSpend": "412500.00",
  "totalSupportEligibleUsageSpend": "399216.00",
  "totalSupportEligibleReservedInstanceSpend": "13284.00",
  "totalSupportEligibleSavingsPlanSpend": "0.0",
  "totalSupportCharge": "33375.00",
  "supportChargePercentage": "0.0809",
  "supportDiscount": "0.0"
}

How to read this:

• isEstimated – Check this first. true means the charge is still an estimate; false means it’s finalized. Don’t reconcile against the invoice until this is false.
• totalSupportEligibleSpend and its three components (usage, Reserved Instances, Savings Plans) sum to the base the tiers are applied against. The RI spend of 13284.00 is included here because the contract used the Upfront method.
• totalSupportCharge – The number that lands on the invoice.
• supportChargePercentage – The effective blended rate across all tiers (here ~8.1%, slightly above the first tier breakpoint).

Step 3: Break the total down per account

This operation turns one invoice line into an itemized, per-account view. It is paginated (the CLI pages automatically, or you can use --page-size, --max-items, and --starting-token) and accepts an optional --account-id to zoom to a single account. Refer to the list-enterprise-support-linked-account-charges documentation for details.

To break the total down per account:

• Pull every linked account for the month

aws billing list-enterprise-support-linked-account-charges \
  --billing-month 2026-07 \
  --output json

• Pull a single account

aws billing list-enterprise-support-linked-account-charges \
  --billing-month 2026-07 \
  --account-id 444455556666 \
  --output json

single entry from the sanitized linkedAccount list:

{
  "accountId": "444455556666",
  "payerAccountId": "111111111111",
  "billableSeconds": 1899686,
  "totalSeconds": 2678400,
  "totalSupportEligibleSpend": "14273.55",
  "proratedTotalSupportEligibleSpend": "10123.68",
  "linkedTimePeriods": [
    { "beginDate": "2024-05-21T10:38:40+00:00", "endDate": "9999-12-31T23:59:59+00:00" }
  ],
  "subscriptionTimePeriods": [
    { "beginDate": "2026-07-02T13:45:03+00:00", "endDate": "2026-07-22T23:41:26+00:00" }
  ],
  "totalSupportEligibleReservedInstanceSpend": "0.0",
  "totalSupportEligibleSavingsPlanSpend": "0.0",
  "supportEligibleSpendByService": []
}

The key story here is proration, told by four fields: totalSeconds (seconds in the month — 2678400 is a 31-day month), billableSeconds (the portion the account was actually subscribed), and totalSupportEligibleSpend versus proratedTotalSupportEligibleSpend. Run the arithmetic:

billableSeconds/totalSeconds = 1,899,686/2,678,400 = 0.7093

0.7093 * 14,273.55 ~= 10,123.68 (proratedTotalSupportEligibleSpend)

An account subscribed for about 71% of the month contributes about 71% of its eligible spend. If a high-spend account didn’t have a large impact on the support charge, this is usually why, it joined partway through the month, and subscriptionTimePeriods tells you exactly when. The supportEligibleSpendByService field can carry a per-service breakdown when you need to go one level deeper.

AWS Solution: Support Breakdown Report

With all three responses, reconciliation is the sum of proratedTotalSupportEligibleSpend across every linked account. It should equal totalSupportEligibleSpend from the charge summary. This AWS Solution will build a per-linked-account CSV of AWS Enterprise Support charges from the public Billing APIs.

Conclusion

In this post, you used three AWS Billing API operations to reconstruct your Enterprise Support charge end to end: get-enterprise-support-contract-details for the rules, get-enterprise-support-charge-summary for the finalized total, and list-enterprise-support-linked-account-charges for the per-account breakdown — then reconciled them with an AWS solution. The monthly question “where did this charge come from?” becomes a self-service API call instead of a support case and a wait.

As a next step, schedule the reconciliation script at month-end and store the per-account breakdown alongside your own cost allocation tags for chargeback.