---
title: Quantity Tier Attributes
slug: quantity-tier-attributes
docTags: 
createdAt: 2026-03-17T21:13:53.446Z
---

# Quantity Tier Attributes

Quantity Tier Attributes (QTA) dynamically resolve discount tiers based on field values such as `Account.NumberOfEmployees`. Instead of applying a flat discount, you configure tiered brackets that automatically select the correct discount percentage based on a quantity-like field at pricing time.

## How QTA Works

The QTA mechanism involves three objects that work together:

1. **QuantityPriceTierAttribute** -- Defines the source field that drives tier resolution (e.g., `Account.NumberOfEmployees`)
2. **ProductPriceDimension** -- A junction object that links a QuantityPriceTierAttribute to a specific product
3. **PriceDimension with PriceTier records** -- Defines the quantity brackets and corresponding discount percentages

When the pricing engine encounters a product with an attached QTA, it reads the value of the source field, finds the matching tier bracket, and applies the configured discount percentage.

### Setup Requirements

| Object                     | Purpose                  | Key Fields                                                |
| -------------------------- | ------------------------ | --------------------------------------------------------- |
| QuantityPriceTierAttribute | Defines the source field | `sourceField` (e.g., `Account.NumberOfEmployees`), `name` |
| ProductPriceDimension      | Links QTA to a product   | `productId`, `quantityPriceTierAttributeId`               |
| PriceDimension             | Groups tier brackets     | `name`, `type`                                            |
| PriceTier                  | Individual tier bracket  | `minQuantity`, `maxQuantity`, `discountPercent`           |

### Example Tier Configuration

| Tier | Min Quantity | Max Quantity | Discount % |
| ---- | ------------ | ------------ | ---------- |
| 1    | 1            | 50           | 0          |
| 2    | 51           | 200          | 10         |
| 3    | 201          | 500          | 15         |
| 4    | 501          | null         | 20         |

If `Account.NumberOfEmployees` is 300, the engine selects Tier 3 and applies a 15% discount.

### Resolution Flow

```javascript
1. Pricing engine identifies product has QTA via ProductPriceDimension
2. Reads the source field value (e.g., Account.NumberOfEmployees = 300)
3. Looks up PriceDimension tiers for the linked QTA
4. Finds the tier where minQuantity <= 300 <= maxQuantity (Tier 3)
5. Applies the tier's discount percentage (15%) as a system discount
```

## Authentication

```javascript
const myHeaders = new Headers();
myHeaders.append("nue-api-key", "YOUR_API_KEY_HERE");
myHeaders.append("Content-Type", "application/json");
```

## Use Case 1: QTA on Bundle Parent

When a QTA is attached to the bundle parent product, the resolved field value drives tier resolution. The resolved discount applies to the parent line item. Pass the tier value using `priceTags` with the HeadcountBucket tier configuration.

```javascript
const myHeaders = new Headers();
myHeaders.append("nue-api-key", "YOUR_API_KEY_HERE");
myHeaders.append("Content-Type", "application/json");

const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "QTA Bundle Parent Quote",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    {
      productSku: "ENTERPRISE_BUNDLE",
      uom: "License/Month",
      quantity: 250,
      priceTags: [{ code: "HEADCOUNT_BUCKET" }],
      addOns: [
        { productSku: "ADDON_SUPPORT", uom: "License/Month", quantity: 1 }
      ]
    }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  const parentLine = result.quoteLineItems[0];
  console.log(`Parent discount (from QTA): ${parentLine.discount}%`);
  console.log(`Parent total: $${parentLine.totalPrice}`);
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "QTA Bundle Parent Quote",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      {
        "productSku": "ENTERPRISE_BUNDLE",
        "uom": "License/Month",
        "quantity": 250,
        "priceTags": [{ "code": "HEADCOUNT_BUCKET" }],
        "addOns": [
          { "productSku": "ADDON_SUPPORT", "uom": "License/Month", "quantity": 1 }
        ]
      }
    ]
  }'
```

With a quantity of 250, the engine resolves to Tier 3 (201-500) and applies a 15% system discount to the parent line.

***

## Use Case 2: QTA on Specific Add-On

A QTA can be attached to an individual add-on product rather than the bundle parent. In this case, only that add-on receives the tiered discount.

```javascript
const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "QTA Add-On Only Quote",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    {
      productSku: "ENTERPRISE_BUNDLE",
      uom: "License/Month",
      quantity: 10,
      addOns: [
        {
          productSku: "ADDON_STORAGE",
          uom: "GB/Month",
          quantity: 500,
          priceTags: [{ code: "STORAGE_VOLUME_TIER" }]
        }
      ]
    }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  const parent = result.quoteLineItems[0];
  const addOn = parent.childrenLineItems[0];
  console.log(`Parent discount: ${parent.discount}%`);  // No QTA -- 0%
  console.log(`Add-on discount: ${addOn.discount}%`);    // QTA resolved
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "QTA Add-On Only Quote",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      {
        "productSku": "ENTERPRISE_BUNDLE",
        "uom": "License/Month",
        "quantity": 10,
        "addOns": [
          {
            "productSku": "ADDON_STORAGE",
            "uom": "GB/Month",
            "quantity": 500,
            "priceTags": [{ "code": "STORAGE_VOLUME_TIER" }]
          }
        ]
      }
    ]
  }'
```

The parent has no QTA and receives no tiered discount. The ADDON\_STORAGE add-on resolves its own tier based on quantity 500.

***

## Use Case 3: QTA on Both Parent and Add-On

When both the bundle parent and an add-on have QTA configurations, each product resolves its tier independently based on its own linked QTA field and quantity.

```javascript
const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "QTA Both Parent and Add-On",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    {
      productSku: "ENTERPRISE_BUNDLE",
      uom: "License/Month",
      quantity: 300,
      priceTags: [{ code: "HEADCOUNT_BUCKET" }],
      addOns: [
        {
          productSku: "ADDON_STORAGE",
          uom: "GB/Month",
          quantity: 100,
          priceTags: [{ code: "STORAGE_VOLUME_TIER" }]
        }
      ]
    }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  const parent = result.quoteLineItems[0];
  const addOn = parent.childrenLineItems[0];
  console.log(`Parent QTA discount: ${parent.discount}%`);  // Tier 3: 15%
  console.log(`Add-on QTA discount: ${addOn.discount}%`);    // Tier 2: 10%
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "QTA Both Parent and Add-On",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      {
        "productSku": "ENTERPRISE_BUNDLE",
        "uom": "License/Month",
        "quantity": 300,
        "priceTags": [{ "code": "HEADCOUNT_BUCKET" }],
        "addOns": [
          {
            "productSku": "ADDON_STORAGE",
            "uom": "GB/Month",
            "quantity": 100,
            "priceTags": [{ "code": "STORAGE_VOLUME_TIER" }]
          }
        ]
      }
    ]
  }'
```

The parent resolves Tier 3 (quantity 300, 15% discount) and the add-on resolves Tier 2 (quantity 100, 10% discount) independently.

***

## Use Case 4: QTA on Nested Bundle

QTA resolution works recursively through nested bundles. If a child bundle has its own QTA, the engine resolves tiers at each nesting level independently.

```javascript
const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "Nested Bundle QTA",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    {
      productSku: "PLATFORM_SUITE",
      uom: "License/Month",
      quantity: 100,
      priceTags: [{ code: "HEADCOUNT_BUCKET" }],
      addOns: [
        {
          productSku: "ENTERPRISE_BUNDLE",
          uom: "License/Month",
          quantity: 50,
          priceTags: [{ code: "HEADCOUNT_BUCKET" }],
          addOns: [
            { productSku: "ADDON_SUPPORT", uom: "License/Month", quantity: 1 }
          ]
        }
      ]
    }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  console.log(`Top-level bundle discount: ${result.quoteLineItems[0].discount}%`);
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "Nested Bundle QTA",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      {
        "productSku": "PLATFORM_SUITE",
        "uom": "License/Month",
        "quantity": 100,
        "priceTags": [{ "code": "HEADCOUNT_BUCKET" }],
        "addOns": [
          {
            "productSku": "ENTERPRISE_BUNDLE",
            "uom": "License/Month",
            "quantity": 50,
            "priceTags": [{ "code": "HEADCOUNT_BUCKET" }],
            "addOns": [
              { "productSku": "ADDON_SUPPORT", "uom": "License/Month", "quantity": 1 }
            ]
          }
        ]
      }
    ]
  }'
```

Each level in the bundle hierarchy resolves its own QTA tier: PLATFORM\_SUITE at quantity 100 (Tier 2: 10%) and ENTERPRISE\_BUNDLE at quantity 50 (Tier 1: 0%).

***

## Use Case 5: Auto-Attached QTA via ProductPriceDimension

When a ProductPriceDimension record links a QTA to a product, the QTA is automatically applied during pricing without any explicit reference in the API request. The engine discovers the QTA configuration from the product's metadata.

This means the API request looks the same as a standard quote -- the QTA discount is applied behind the scenes.

```javascript
const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "Auto-Attached QTA",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    { productSku: "VOLUME_LICENSE", uom: "User/Month", quantity: 400 }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  const line = result.quoteLineItems[0];
  console.log(`Auto-attached QTA discount: ${line.discount}%`);
  console.log(`List price: $${line.listTotalPrice}`);
  console.log(`Total price: $${line.totalPrice}`);
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "Auto-Attached QTA",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      { "productSku": "VOLUME_LICENSE", "uom": "User/Month", "quantity": 400 }
    ]
  }'
```

No `priceTags` are needed in the request. The engine detects the QTA link via ProductPriceDimension and applies the Tier 3 discount (15%) automatically for quantity 400.

***

## Use Case 6: QTA + Discretionary Discount Stacking

QTA discounts are system-level discounts. You can stack an explicit discretionary discount on top of the QTA-resolved discount. The pricing engine applies the QTA discount first (as a system discount), then applies the discretionary discount to the resulting subtotal.

**Pricing formula with stacking:**

`listPrice x quantity x term = listTotal` -> `listTotal x (1 - qtaDiscount/100) = subtotal` -> `subtotal x (1 - discretionaryDiscount/100) = totalPrice`

```javascript
const quoteData = {
  opportunityId: "006xx000001abc123",
  name: "QTA + Discretionary Discount",
  subscriptionStartDate: "2026-01-01",
  subscriptionEndDate: "2027-01-01",
  subscriptionTermDimension: "Month",
  subscriptionTerm: 12,
  products: [
    {
      productSku: "VOLUME_LICENSE",
      uom: "User/Month",
      quantity: 400,
      discount: 5
    }
  ]
};

fetch('https://api.nue.io/cpq/quotes:preview', {
  method: 'POST',
  headers: myHeaders,
  body: JSON.stringify(quoteData)
})
.then(response => response.json())
.then(result => {
  const line = result.quoteLineItems[0];
  console.log(`QTA system discount: resolved from tier`);
  console.log(`Discretionary discount: ${line.discount}%`);
  console.log(`List total: $${line.listTotalPrice}`);
  console.log(`Final total: $${line.totalPrice}`);
})
.catch(error => console.log('Error:', error));
```

```bash
curl -X POST 'https://api.nue.io/cpq/quotes:preview' \
  -H 'nue-api-key: YOUR_API_KEY_HERE' \
  -H 'Content-Type: application/json' \
  -d '{
    "opportunityId": "006xx000001abc123",
    "name": "QTA + Discretionary Discount",
    "subscriptionStartDate": "2026-01-01",
    "subscriptionEndDate": "2027-01-01",
    "subscriptionTermDimension": "Month",
    "subscriptionTerm": 12,
    "products": [
      {
        "productSku": "VOLUME_LICENSE",
        "uom": "User/Month",
        "quantity": 400,
        "discount": 5
      }
    ]
  }'
```

The auto-attached QTA resolves Tier 3 (15% system discount) for quantity 400. The explicit 5% discretionary discount stacks on top, resulting in an effective combined discount.

## How QTA Interacts with Other Discounts

| Discount Type               | Applied By                     | Stacking Order        | Override Behavior                                 |
| --------------------------- | ------------------------------ | --------------------- | ------------------------------------------------- |
| QTA system discount         | Pricing engine (automatic)     | Applied first         | Cannot be overridden by request                   |
| Discretionary line discount | `discount` field on product    | Applied after QTA     | Stacks on top of QTA                              |
| Header discount             | `discount` field on quote root | Applied after QTA     | Stacks on top of QTA; overridden by line discount |
| Price tag discount          | `priceTags` on product         | Applied alongside QTA | Both evaluate independently                       |

## Key Behaviors

| Behavior                   | Description                                                             |
| -------------------------- | ----------------------------------------------------------------------- |
| **Auto-discovery**         | QTA linked via ProductPriceDimension is applied automatically           |
| **Independent resolution** | Each product resolves its own QTA tier independently                    |
| **System discount**        | QTA discounts are treated as system-level discounts, not discretionary  |
| **Stacking**               | Discretionary discounts stack on top of QTA discounts                   |
| **Nested support**         | QTA works at any nesting level within bundle hierarchies                |
| **Null max quantity**      | The highest tier can use `null` as max quantity for open-ended brackets |
| **Price tag delivery**     | QTA tiers can be referenced via `priceTags` with the tier code          |