---
title: "AWS Marketplace Decimal Usage: When to Switch"
url: https://www.fours.com/resources/blog/aws-marketplace-decimal-usage/
canonical: https://www.fours.com/resources/blog/aws-marketplace-decimal-usage/
type: Blog
description: "AWS Marketplace metering now takes six decimal places and deprecates the whole-number fields. When to switch, and what exact fractions do to the bill."
---

# AWS Marketplace Decimal Usage: When to Switch

> Canonical HTML version: https://www.fours.com/resources/blog/aws-marketplace-decimal-usage/

1.  [Home](/)
2.  [Resources](/resources/)
3.  [Blog](/resources/blog/)
4.  AWS Marketplace Decimal Usage: When to Switch

# AWS Marketplace Decimal Usage: When to Switch

AWS Marketplace metering now takes six decimal places and deprecates the whole-number fields. When to switch, and what exact fractions do to the bill.

[![Shirley Guo](/authors/shirley-guo.jpg)](/resources/blog/author/shirley-guo/)

[Shirley Guo](/resources/blog/author/shirley-guo/)

Nov 18, 2026

 ![AWS Marketplace Decimal Usage: When to Switch](/images/blog/aws-marketplace-decimal-usage/hero.png)

AWS Marketplace decimal usage became available on November 16, 2026. `MeterUsage` and `BatchMeterUsage` now take quantities with up to six decimal places, through new decimal fields, and AWS’s API reference now marks the whole-number fields beside them as deprecated (“Use `QuantityAsDecimal` instead,” says the usage record reference). Integrations that send whole numbers keep working, and AWS has set no date for removing the old fields.

That makes two decisions, and they are easy to run together. Moving to the decimal field is a question of when, because a whole number is a valid decimal: you can switch fields without billing a single fraction. Sending fractions is a pricing decision, and what it does to the buyer’s bill depends on what your pipeline does with a fraction today. This post takes them in that order: the field, what breaks during the switch, then the fractions.

## What changed in AWS Marketplace metering?

**Each metering call and usage allocation gained a decimal quantity field, sent as a string with up to six decimal places, and the whole-number field it replaces is deprecated.** AWS’s announcement gives “reporting 1.5 terabytes (TB) of storage instead of 1 or 2 TB” as the example, and the change applies in all AWS Regions where AWS Marketplace Metering Service is available.

| Where the quantity goes | Whole-number field (deprecated) | Decimal field | Who sends it |
| --- | --- | --- | --- |
| A usage record in `BatchMeterUsage` | `Quantity` | `QuantityAsDecimal` | SaaS products |
| A `MeterUsage` request | `UsageQuantity` | `UsageQuantityAsDecimal` | Software in the buyer’s account: AMI, container and AgentCore Runtime deployments |
| A usage allocation (vendor-metered tags) | `AllocatedUsageQuantity` | `AllocatedUsageQuantityAsDecimal` | Either, when you split usage by tag |

All three decimal fields share one format. AWS defines the value as “a non-negative decimal number, for example 17.42,” sent as a string that must match `^(0|[1-9][0-9]{0,9})(\.[0-9]{1,6})?$`: up to ten digits before the point, one to six after it, no sign, no exponent and no leading zero (`0.5` is valid, `05` is not). A record can’t carry both fields. The range grows too: the deprecated integer fields stop at 2,147,483,647, while the decimal string allows ten digits before the point.

## When should you switch to the decimal field?

**In your next metering release, whatever you decide about fractions.** A whole number is valid in the decimal field (`"17"` matches the pattern), and AWS compares quantities by value: “`17`, `17.0`, and `17.00` are the same quantity, whether you send it in `Quantity` or `QuantityAsDecimal`.” Switching the field and sending the same whole numbers changes nothing on the buyer’s bill.

There is no deadline to beat. AWS says “existing integrations that report whole numbers continue to work without changes” and gives no removal date for `Quantity` or `UsageQuantity`. The case for not waiting is that the switch is smallest while it is only a field change. Leave it until you also start sending fractions, and a failed deploy and a change to every buyer’s bill arrive in the same release.

The switch, in order:

1.  **Update the AWS SDK first, then check the request it actually sends.** The decimal members are new, so a client built before November 16 doesn’t know them. If a client drops a member it doesn’t recognize, the record leaves with neither quantity field, and AWS’s default applies: the quantity “Defaults to 0 if neither `Quantity` nor `QuantityAsDecimal` is specified.” Log one serialized request and confirm the field is in it.
2.  **Send a string you formatted yourself.** The field is a string, not a JSON number, and it takes at most six decimal places. Default float printing breaks that: in most languages `0.1 + 0.2` prints as `0.30000000000000004`, and very small or very large values print in exponent notation. Round to six places or fewer with one rule, format without an exponent, and use that rule everywhere you build records.
3.  **Move allocations in the same change.** If you send vendor-metered tags, each allocation must use its record’s quantity type: `AllocatedUsageQuantityAsDecimal` with `QuantityAsDecimal`. How allocations work in the first place is covered in [AWS Marketplace vendor-metered tagging](/resources/blog/aws-marketplace-vendor-metered-tagging/).
4.  **Retry with the value you sent, not a recomputed one.** A retry that crosses the deploy, resending `Quantity` 17 as `QuantityAsDecimal` `"17.00"`, is the same quantity, so it isn’t billed twice. A retry with a different value is not a correction: for `BatchMeterUsage`, “if you meter for a different quantity, the original quantity is billed,” and `MeterUsage` answers with `DuplicateRequestException`. Store the string you sent with each record, and resend that.

## What breaks a decimal metering request?

**Mostly records that mix the two quantity types. In `BatchMeterUsage`, a record with both fields, or a decimal record with whole-number allocations, fails the whole request.** In AWS’s words: “If any usage record fails these checks, the entire `BatchMeterUsage` request fails and no records are processed.” With up to 25 records in a call, one bad record holds back the other 24, so test the change in the code every record passes through, not on one path.

| What the code does | What AWS does |
| --- | --- |
| Sets both `Quantity` and `QuantityAsDecimal` on one record | Fails the “You can’t specify both” check, and the whole `BatchMeterUsage` request with it |
| Sends a decimal record with whole-number allocations, or the reverse | `InvalidUsageAllocationsException`, which now covers the type as well as the sum: “the allocations don’t use the same type of quantity (whole number or decimal) as the usage quantity”. For a decimal record with whole-number allocations, AWS says the whole `BatchMeterUsage` request fails |
| Splits a decimal quantity into allocations that miss by the last place | `InvalidUsageAllocationsException`: the allocations must sum to the record’s quantity. Three equal shares of 1, rounded to six places, add up to 0.999999, so give the remainder to one allocation |
| Sends neither field | Records a quantity of 0 |
| Resends an hour with a different value | Bills the original quantity (`BatchMeterUsage`) or returns `DuplicateRequestException` (`MeterUsage`) |
| Sends a value with seven decimal places, or in exponent notation | Doesn’t match the field’s pattern, so it isn’t a valid quantity |

## Should you send fractions?

**Send them once billing the exact quantity is what you mean to charge. What that changes for the buyer depends on what you do with a fraction today.** AWS bills what you send: it “calculates charges from the exact usage quantity that you send, including all decimal places.” So switching moves the bill by whatever your rounding was adding or removing.

Take one illustrative buyer on a dimension priced per TB scanned, over four hours, under each common way of handling a fraction:

| Per hour, in TB | 13:00 | 14:00 | 15:00 | 16:00 | Four-hour total |
| --- | --- | --- | --- | --- | --- |
| Measured usage | 1.5 | 0.25 | 2.75 | 0.4 | 4.9 |
| Round up | 2 | 1 | 3 | 1 | 7 |
| Round to nearest | 2 | 0 | 3 | 0 | 5 |
| Round down (drop the fraction) | 1 | 0 | 2 | 0 | 3 |
| Carry the remainder | 1 (0.5 held) | 0 (0.75 held) | 3 (0.5 held) | 0 (0.9 held) | 4, with 0.9 held |
| `QuantityAsDecimal` | `"1.5"` | `"0.25"` | `"2.75"` | `"0.4"` | 4.9 |

The decision follows from the row you are on today:

| What you do with a fraction today | Exact decimals do this to the bill | What reconciliation gains | Before you send fractions |
| --- | --- | --- | --- |
| Round up | Lowers it. A partial unit stops billing as a whole one: 7 becomes 4.9 above. | AWS’s quantities stop running above your measured usage. | Decide whether the round-up was doing a job, such as a minimum charge on a light hour. If it was, that is a price to set on purpose, not a side effect to keep. |
| Round to nearest | Moves each record by up to half a unit, either way. The net depends on your usage pattern: 5 becomes 4.9 above. | Hour-by-hour differences in both directions disappear. | Run last month’s usage both ways and size the net change. |
| Round down, or drop the fraction | Raises it. Usage you were giving away starts to bill: 3 becomes 4.9 above. | AWS’s quantities stop running below your measured usage. | Tell buyers before their bills rise. A buyer whose charges climb with no change in usage will ask why. |
| Carry the remainder | Changes only the timing. Each fraction bills in its own hour instead of the hour the running total completes a unit. | Every hour matches, and the remainder bookkeeping goes away. | At the switch, add each buyer’s held remainder to their first decimal record, or it never bills. |

## What will reconciliation show after the switch?

**The charge uses every decimal place you send, but several AWS surfaces show fewer, so reconcile against the values you sent or the Cost and Usage Report, not a dashboard.** AWS’s metering pages for SaaS, AMI and container products carry the same note:

| Where the quantity appears | Decimal places |
| --- | --- |
| The charge AWS calculates | Every place you send |
| Usage dashboard | 2 (AWS’s example: 17.123456 shows as 17.12) |
| Daily Usage data feed | 2 |
| Bills page, AWS Billing and Cost Management console | Up to 3 |
| AWS Cost and Usage Reports | Floating point, exact up to 15 significant digits. AWS’s example: 9999999999.999999 can show as 9999999999.999998 |

Two things follow. A row on the Usage dashboard or the Daily Usage data feed can differ from your own figure for it by less than 0.01 and still be right, so set your match tolerance there instead of investigating each one. And a buyer who checks the Bills page may find the quantity times the price doesn’t quite equal the charge, because the charge used more decimals than the page shows. The Cost and Usage Report shows the quantity in full, up to 15 significant digits.

## Which sellers should send fractions now?

**Most should switch the field now and send fractions only once the change to the bill is one they chose.** By starting point:

-   **Usage that only comes in whole units**, such as seats, hosts or API requests: switch the field and keep sending whole numbers. There is nothing else to decide.
-   **Pipelines that carry the remainder:** switch, send exact quantities, and move each buyer’s held remainder into the first decimal record. The buyer’s total doesn’t change, and the remainder bookkeeping retires.
-   **Pipelines that round up:** switch the field now, and send fractions once you have decided the round-up wasn’t part of the price.
-   **Pipelines that round down or drop the fraction:** switch the field now, and send fractions after buyers know their bills will rise by the usage you weren’t billing.
-   **A dimension whose unit was chosen to avoid fractions**, such as per GB where buyers think in TB: decimals change only the quantity you can report. The dimension’s unit and price are what you published, and whether a coarser unit would now suit you is a dimension decision. [Designing metering dimensions](/resources/blog/designing-metering-dimensions/) covers what changing one commits you to.

## How does Fours handle fractional AWS usage today?

**Fours carries the remainder: it reports whole units to AWS and keeps any fraction on the entitlement.** You send usage to the Fours Metering API with a `quantity` that Fours’ docs define as a “float or integer number”, so 1.5 TB is a valid report. Each hour, Fours sums each entitlement’s unreported usage per dimension and sends one report per entitlement. When AWS auto-renews an agreement, Fours creates a new entitlement for the renewal term, and once the old entitlement’s final usage report is done, the held fraction moves to the renewed one and combines with later usage there.

That puts a SaaS listing metered through Fours in the carry row above: a fraction bills in the hour the running total completes a unit, not the hour it was used. What it leaves to you: if you round before sending usage to Fours, your row is your own rounding, not the carry. AMI and container products report with `MeterUsage` from inside the buyer’s instance or container, which Fours doesn’t do on your behalf, so the field switch there is yours, as it is for any usage you send straight to `BatchMeterUsage`. The request format and validation rules are in [Usage Metering in Fours’ docs](https://doc.fours.com/metering/usage-metering/).

## What do Microsoft and Google Cloud say about fractional quantities?

**Microsoft’s usage events carry a numeric quantity that must be above zero, and Google Cloud bills at the granularity of a reporting unit the seller picks.** In their own words:

| Marketplace | What its docs say |
| --- | --- |
| Microsoft | The usage event sample sends `"quantity": 5.0`, commented “must be greater than 0 or a double integer”. The `InvalidQuantity` error reads “The quantity passed is lower or equal to 0.” |
| Google Cloud | Each metric has a reporting unit, “which represents the granularity with which you measure your product’s usage”. At $0.256 per gibibyte reported by mebibyte, 512 MiB costs $0.128. Reported by gibibyte, the buyer is “charged the full $0.256, even if they only use a fraction of a gibibyte.” |

One difference reaches code that meters both AWS and Microsoft: AWS accepts a quantity of `0`, and Microsoft rejects it.

Whether usage pricing suits your AWS listing at all, and what each model commits your integration to, is the subject of [AWS Marketplace contract pricing vs usage pricing](/resources/blog/aws-marketplace-contract-vs-usage-pricing/).

## Sources

Primary sources for the platform rules cited above. Last verified November 18, 2026. Cloud providers change fees, eligibility, and program terms without notice — check the source before relying on a figure.

-   [AWS What's New: AWS Marketplace Metering Service now supports decimal usage quantities](https://aws.amazon.com/about-aws/whats-new/2026/11/aws-marketplace-metering-service-decimal-usage-quantities/) — Posted November 16, 2026: up to six decimal places in MeterUsage and BatchMeterUsage through UsageQuantityAsDecimal, QuantityAsDecimal and AllocatedUsageQuantityAsDecimal, the 1.5 TB example, integrations that report whole numbers continuing to work without changes, and availability in all AWS Regions where the Metering Service is available
-   [AWS Marketplace API Reference: UsageRecord](https://docs.aws.amazon.com/marketplace/latest/APIReference/API_marketplace-metering_UsageRecord.html) — Quantity deprecated (a whole number from 0 to 2,147,483,647 that defaults to 0 when neither field is set); QuantityAsDecimal as a non-negative decimal string, its pattern and its 17-character limit; never both in one record; allocations that must sum to the record's quantity and use its type; the entire BatchMeterUsage request failing when any record fails these checks; 17, 17.0 and 17.00 compared by value
-   [AWS Marketplace API Reference: UsageAllocation](https://docs.aws.amazon.com/marketplace/latest/APIReference/API_marketplace-metering_UsageAllocation.html) — AllocatedUsageQuantity deprecated, AllocatedUsageQuantityAsDecimal and its pattern, and exactly one of the two on each allocation
-   [AWS Marketplace API Reference: MeterUsage](https://docs.aws.amazon.com/marketplace/latest/APIReference/API_marketplace-metering_MeterUsage.html) — Software in the buyer's account calls it (EC2, EKS, ECS and AgentCore Runtime deployments); UsageQuantity deprecated in favour of UsageQuantityAsDecimal; allocations of the same quantity type; DuplicateRequestException for a different quantity in an hour already metered, compared by value; InvalidUsageAllocationsException covering the sum and the quantity type
-   [AWS Marketplace API Reference: BatchMeterUsage](https://docs.aws.amazon.com/marketplace/latest/APIReference/API_marketplace-metering_BatchMeterUsage.html) — SaaS applications call it; QuantityAsDecimal for fractional usage; up to 25 usage records a request; InvalidUsageAllocationsException covering the sum and the quantity type
-   [AWS Marketplace Seller Guide: Configuring metering for usage with SaaS subscriptions](https://docs.aws.amazon.com/marketplace/latest/userguide/metering-for-usage.html) — The QuantityAsDecimal format; charges calculated from the exact quantity sent; the decimal places shown by the Usage dashboard, the Daily Usage data feed, the Bills page and Cost and Usage Reports; hourly deduplication, with the original quantity billed when a retry sends a different one; allocations that match the record's quantity and type; usage shown in the buyer's Billing and Cost Management console
-   [AWS Marketplace Seller Guide: Configuring custom metering for AMI products](https://docs.aws.amazon.com/marketplace/latest/userguide/custom-metering-with-mp-metering-service.html) — UsageQuantityAsDecimal for fractional usage and the same note on exact charges and display precision
-   [AWS Marketplace Seller Guide: Configuring custom metering for container products](https://docs.aws.amazon.com/marketplace/latest/userguide/container-metering-meterusage.html) — UsageQuantityAsDecimal for fractional usage and the same note on exact charges and display precision
-   [Microsoft Learn: Metering service APIs, Microsoft Marketplace](https://learn.microsoft.com/en-us/partner-center/marketplace-offers/marketplace-metering-service-apis) — The usage event sample's quantity of 5.0 and its comment, and the InvalidQuantity error for a quantity lower or equal to 0
-   [Google Cloud Marketplace Partners: Choosing and submitting your pricing model](https://docs.cloud.google.com/marketplace/docs/partners/integrated-saas/select-pricing) — A reporting unit per metric as the granularity of measured usage, and the $0.256-per-gibibyte example reported by mebibyte and by gibibyte
-   [Fours docs: Usage Metering](https://doc.fours.com/metering/usage-metering/) — Fours behaviour: quantity as a float or integer number; each hour, one report per entitlement summing its unreported usage per dimension; AMI and container usage reported from inside the instance or container with MeterUsage, not by Fours
-   [Fours docs: AWS Marketplace Accept Private Offer](https://doc.fours.com/aws-marketplace/accept-private-offer/) — Fours behaviour: an AWS auto-renewal creates a new entitlement; Fours reports whole units and keeps any fraction on the entitlement, moving it to the renewed entitlement once the old one's final usage report is done
