---
title: Bundles: Managing Resources as One Versioned Unit
slug: resource-bundles
description: Learn how PacManage Bundles group versioned packing resources under one slug. Explore setup, API requests, version controls, and best practices for testing, promoting, and rolling back configuration changes securely across development, QA, and production.
image: https://cdn.images.archbee.com/TJI5tEN_yTs0kLVGBF9mT/FlJcI9GYP1gYVZcCkmZ9P_pacmanage-bundle-design.png
docTags: PRQq_lBQtwy-4NNFrbNb8,iMBOqa61ybgVkWAT3F59-,1TaQf9nerJM0hn0bzoh86
createdAt: 2026-11-20T20:26:54.418Z
---

![Bundle Management in PacManage](https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/IQq3ofs5mso5gur40aAVn_pacmanage-bundle-design.png "Bundle Management in PacManage")

A Bundle lets your integration reference one slug while PacManage™ decides which cartons, rules, rates, and item data stand behind it. You change packing configuration in the Packing Control System (PCS), and your WMS, ERP, or TMS payload never has to change.

## What a Bundle is, and why to use one

A Bundle is a resource in the PacManage™ Resource Library that holds a list of other resources, each locked to a specific version. When a pack request references the Bundle's slug, PacAPI pulls in every resource in the Bundle lists, at the version the Bundle names, and merges them into the request.

Individual resource slugs already move configuration out of your system of record, but they leave two problems open. First, adding a resource (a seasonal carton set, an Item List, a new rule) means editing the packResources array in your client system, which usually means an IT ticket and a deploy. Second, any edit to a resource reaches live traffic within about 30 seconds, so there is no gap available to test a change and then push it to production.

Bundles close both gaps:

- **One reference, permanently.** Your payload references the Bundle once. Adding or swapping resources later happens inside PacManage™, with no code change within your client system.
- **A buffer between edits and production.** Because each resource in a Bundle is pinned to a version, editing a resource in the Library does not change what live requests use until someone promotes the new version into the Bundle.

## How a Bundle resolves its resources

Each entry in a Bundle references a resource and which version of it to use. That version setting decides whether a change in the Resource Library reaches your pack requests immediately, when someone publishes it, or only when someone updates the Bundle itself.

| Version setting                        | What the Bundle uses                                                    | When a resource edit reaches pack requests                  | Best for                                                            |
| -------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------- |
| **Pin to a version** (for example V13) | Exactly that version, regardless of later edits                         | Only after someone changes the pinned version in the Bundle | Production and QA                                                   |
| **Use published version**              | Whichever version is currently marked Published in the Resource Library | When someone publishes a new version of the resource        | Teams that already review and publish resource changes deliberately |
| **Always use the newest version**      | The newest saved version, even before it is published                   | Within about 30 seconds of saving                           | Development and testing                                             |

You choose the setting for each resource in the Bundle's **Version setting** dialog. The choice applies only to that Bundle, so other Bundles that include the same resource keep their own settings.

![](https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/VMFTC23GxOpQkoGNEMntW_version-setting.png)

When a request references a Bundle, the PCS resolves it in four steps:

1. PacAPI's resource-enabled endpoint (`https://resources.api.paccurate.io`) receives your request and reads the slugs in `packResources`.
2. It expands the Bundle into its listed resources, at the versions the Bundle is referencing.
3. It merges those resources into your request: carton, item, and order lists are combined, and rules and settings are merged together into a final request.
4. PacAPI packs the merged request and returns the result. The response records which resources were used and when each was last updated, so you can always tell which configuration produced a given pack.

The endpoint caches the expanded Bundle and refreshes it when the Bundle changes, rather than fetching every resource on every request.

## Creating and managing a Bundle in PacManage™

You build a Bundle from resources that already exist in your Resource Library, so create your cartons, rules and settings, rates, item lists, and box type generators first. A Bundle is a resource like any other: it has a name, a slug, a description, tags, and its own version history.

### Create a Bundle

![Bundle List view](https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/stGX9O_H02C18eTKU2bTu_bundle-list.png)

1. Log in to manage.paccurate.io and open your plan's Bundles page under PacManage.
2. Click the **Create Bundle** button
3. Add the resources the Bundle should include. For each one, choose a version setting: **Pin to a version**, **Use published version**, or **Always use the newest version**.
4. Give the Bundle a name, description, and tags that make its purpose obvious, such as the site location, environment, or season it serves.
5. Save the Bundle and copy its slug from the resource card. That slug is what your integration sends.

### Update a resource and manage its versions

Every time you save a resource, PacManage™ creates a new version and keeps the earlier ones. That version history is what makes testing, promotion, and rollback possible.

- **Edit the resource.** Open it in the Resource Library and edit fields directly, or use **Replace source** to upload a replacement CSV or XLSX file.&#x20;
- **Save and publish.** Saving creates a new version. **Save and publish** also marks that version Published, which matters for any Bundle set to **Use published version**. The badge at the top right of the resource shows its current version and status, such as V2 · Published.&#x20;

![Resource Version set](https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/XDeasOHbnIhjVgZeSK0sK_picture1.png)

- **Review version history.** Version history lists every saved version, who saved it, and when. From there you can **Publish** an older version, **Restore** it, download it, or **Compare** it with another version to see which rows were added, removed, or edited.&#x20;

::Image[]{src="https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/9M9657U4eYpvuuG8vi24g_compare-version-redacted.png" size="100" isUploading="false" position="center" width="1352" height="552" darkWidth="1352" darkHeight="552" alt="Compare Versions" showCaption="false" indent="1"}

### Update a Bundle

Every change to a Bundle saves a new version of the Bundle, and pack requests that reference its slug pick up the change automatically. Common updates include:

- **Promoting a resource change.** After you edit and validate a resource, open the Bundle, select the resource's version in the **Used Version** column, and pin the new version.
- **Adding a resource.** Attach a new carton list, rule set, rate table, box type generator, or Item List to the Bundle. Your payload settings do not change.
- **Removing or swapping a resource.** Replace a seasonal carton list with the standard one when peak ends.
- **Rolling back.** If a change causes problems, set the affected resource back to its previous version number in the Bundle.

Because the Bundle keeps a version history, you can see what changed, when, and who changed it. The Bundle's resource table shows each resource's **Used Version** (for example, V13 · pinned or V15 · published) next to its **Latest Version**, so you can see at a glance when a Bundle is behind the newest edit.

## Using a Bundle in a pack request

A Bundle slug goes in `packResources`, exactly where an individual resource slug would, and you send the request to the resource-enabled endpoint (`https://resources.api.paccurate.io`) with your usual Authorization header.

### Before and after

Without a Bundle, your client system carries every slug and must be updated whenever the list changes:

```json
{
  "orderId": "ORD-100231",
  "itemSets": [ { "refId": 8988, "quantity": 6, "weight": 1, "dimensions": { "x": 3, "y": 14, "z": 18 } } ],
  "packResources": [
    "base-settings-2026",
    "cartons-global",
    "seasonal-cartons-west-fc",
    "kit-box-rules-2026"
  ]
}
```

With a Bundle, the same configuration is one reference that never needs to change:

```json
{
  "orderId": "ORD-100231",
  "itemSets": [ { "refId": 8988, "quantity": 6, "weight": 1, "dimensions": { "x": 3, "y": 14, "z": 18 } } ],
  "packResources": ["west-fc-production"]
}
```

If the Bundle includes an Item List, your request can identify items by refId or name and quantity alone, and their dimensions, weights, and properties resolve from the Bundle.

### Combining a Bundle with other slugs

A Bundle does not have to be the only entry in packResources. You can send a shared baseline Bundle plus extra resources or Bundles for a specific customer, channel, or site, and the PCS merges them all:

```json
"packResources": ["baseline-2026", "vip-customer-rules", "vip-cartons-fall"]

```

Understanding the payload and Bundles merge

| What the request contains                                                   | Result                                                                         |
| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Several carton, item, or order resource slugs                               | Their rows are combined into one list                                          |
| Several rules and settings resource slugs                                   | Rules are combined; for a setting defined more than once, the later value wins |
| boxTypes sent inline in the request, plus carton resource slugs             | The inline boxTypes replace the cartons from your resources                    |
| Rate table resource, plus boxTypeDefaults.rateTable with a service and zone | The matching rates are applied for that service and zone                       |

## Recommended setup: a Bundle for each environment

Give each environment, such as Development, QA, and Production, its own API key and its own Bundle. Each Bundle can contain the same resources; what differs is which version of each resource it uses. Development needs to reflect changes instantly so your team can test them, QA needs to hold still for a test cycle, and Production needs to stay put until someone approves a change. One Bundle cannot do all three.

|                                   | Development                                          | QA                                           | Production                              |
| --------------------------------- | ---------------------------------------------------- | -------------------------------------------- | --------------------------------------- |
| API key                           | Dedicated Dev key                                    | Dedicated QA key                             | Dedicated Production key                |
| Bundle version settings           | **Always use the newest version** for every resource | **Pin to a version**: the version under test | **Pin to a version** for every resource |
| When a resource edit takes effect | Within about 30 seconds                              | When QA pins it for a test cycle             | Only when promoted into the Bundle      |
| Who changes it                    | Anyone configuring or testing                        | The QA owner                                 | A named owner, after validation         |

### Promoting a change to production

1. **Update the resource.** Edit it in the Resource Library, such as adding a carton or adjusting a rule, and save. This creates a new version.
2. **Test in Development.** Your Development Bundle picks up the new version automatically. Send test requests with your Development key and review the results in Inspector.
3. **Promote to QA.** Open the QA Bundle, select the resource's version in the **Used Version** column, choose **Pin to a version**, and select the version to test.
4. **Review what changed (optional).** In the resource's version history, use **Compare** to see which rows were added, removed, or edited between two versions.
5. **Promote to Production.** Once QA approves, pin the same version in the Production Bundle. For example, if version 16 passed Development and QA, pin Production to version 16. Production traffic starts using it as soon as the change is saved.
6. **Roll back if needed.** If a problem appears in production, pin the resource back to its previous version in the Production Bundle. Production returns to its earlier behavior on the next request.



If a resource is updated by an automated, scheduled sync from your system of record (for example, an Item List fed by your dimensioner or WMS), it can be reasonable to let that one resource follow latest in production. Hand-edited cartons and rules should still be pinned and promoted deliberately.

![Promoting Resources in bundles](https://api.archbee.com/api/optimize/TJI5tEN_yTs0kLVGBF9mT/WdmmXF3khILgIAFm1SfyO_picture1-promotet-to-qa.png)

### ⚠️  Avoid these setups

- **One key for both testing and live traffic.** A rule edit meant for testing goes live immediately, and there is no way to tell test requests from production ones.
- **A Production Bundle set to Always use the newest version.** Every resource edit, including a mistaken one, reaches live orders within seconds.
- **Loose slugs instead of a Bundle.** Every new resource requires a change and a deploy in your client system. This works if you are dynamically composing requests with known associations of resource slugs, but can be challenging to maintain across systems

### Default Bundles on an API key

Paccurate can assign a default Bundle to an API key, so requests made with that key use the Bundle even when the payload carries no packResources slugs. Your client system then only needs its key and the order's items. Contact your Paccurate team to set this up.

## Operator use-cases for Bundles

The three scenarios below come from live Paccurate implementations, with customer names and slugs changed.

### Going live, then growing without IT tickets: an apparel retailer

An activewear retailer went live at its western fulfillment center with three resources: a carton list, a rule set, and an options resource. Its rule set was already on its seventh revision before go-live, and after launch any payload change would have to go through the retailer's integration partner.

Instead of sending three slugs, the integration sends one Bundle slug. Version 1 of the Bundle pins the rules at version 7 and the cartons and options at version 1:

```json
{
  "resources": [
    { "slug": "apparel-packing-rules", "type": "rules-settings", "version": 7 },
    { "slug": "apparel-cartons", "type": "cartons", "version": 1 },
    { "slug": "apparel-options", "type": "options", "version": 1 }
  ]
}
```

To add an Item List and a set of folding and nesting rules for soft goods, the team attaches both to the Bundle in PacManage™. Version 2 of the Bundle carries five resources, and the integration partner changes nothing.

To expand to a second fulfillment center that stocks styles the first site does not have, the retailer can create a second Bundle for that site with the shared cartons, rules, and options plus the new site's Item List. Each site's integration then references its own Bundle.

### One baseline setup, with separate account variation: a multi-brand distributor

A distributor fulfills orders for many retail accounts. Most packing behavior is the same for every account, including cartons, maximum weights, and stacking and nesting, but some accounts need extra rules or their own cartons.

The distributor keeps that shared behavior in one baseline Bundle that every request sends. For accounts with special requirements, the integration appends that account's resources:

```javascript
"packResources": ["distributor-baseline-2026", "vip-account-rules", "vip-account-cartons-fall"]
```

The distributor's client system only needs naming logic that maps an account to its slugs. Everything those slugs contain lives in PacManage™, where the operations team can change it.

### Item names in, packed orders out: a health and beauty distributor

A health and beauty distributor with three distribution centers sends requests that identify each item by name and quantity only, with no dimensions, rules, or carton list in the payload:

:::BlockQuote
\{
&#x20; "itemSets": \[
&#x20;   \{ "name": "SKU-48213", "quantity": 12 },
&#x20;   \{ "name": "SKU-77105", "quantity": 8 }
&#x20; ],
&#x20; "packResources": \["distributor-default"]
}
:::

```json
```

The Bundle supplies the Item List with dimensions and properties, the carton list, and the rules. When the distributor's packing logic changes, the change happens in the Bundle, and its automated storage system's integration is untouched.

Bundles can also be leveraged to pack the same order with multiple objectives and decide what is best for a given use case — store replenishment for example.

## Bundle FAQs

**Is a resource Bundle the same as bundling items into a kit?**
&#x20;No. Resource Bundles group packing configurations. Packing a set of items together as a kit before final packout is a packing *rule* for something such as kit-bundles. See Multi-stage Packing for kitting.

**Do I have to stop using individual resource slugs?**
&#x20;No. Individual slugs in packResources keep working exactly as before, and you can send them alongside a Bundle.

**What happens to live orders when I edit a resource that a Production Bundle pins?**
&#x20;Nothing, until you raise that resource's version number in the Bundle. Live requests keep using the pinned version.

**Can a Bundle include another Bundle?**
&#x20;Not today. To share resources between sites, list the shared resources in each site's Bundle, or send a baseline Bundle plus site-specific slugs in packResources.

**How do I know which configuration produced a pack?**
&#x20;The pack response records the resources used and when each was last updated. Open the pack in Inspector and check the Raw tab to view the JSON.

## Related documentation

- [Resources: Integration Guide:](https://docs.paccurate.io/resources-integration-guide) the resource-enabled endpoint and request mechanics
- [Resource Types & Functionality:](https://docs.paccurate.io/resource-types) creating cartons, rules and settings, and rates resources
- [Multi-stage Packing:](https://docs.paccurate.io/multi-stage-packing) kitting and staged packing with pack-sequence
