Charging Methods
Shopify charges the price of real things in a cart. A configured price therefore has to become real cart contents somehow, and there are four ways to do that. You pick one per project, as Charging method under Pricing and charging in the project's Storefront settings. Press Save settings, and the change takes effect on your next publish.
Use Product lines unless you know you need another one. It is the recommended method: it works on every Shopify plan, handles every kind of pricing, charges your own products at the price Shopify sets for them, and keeps each configuration together in the cart.
It is also the one method that follows every market. Each piece of the configuration reaches the cart as a line Shopify prices for the shopper's market - your own products, and the hidden lines for the amounts you set in the Composer alike - so another currency, a percentage adjustment, price rounding and tax that depends on the shopper's country all apply the way they do to your other products, and the configurator shows the total the cart collects. Where a market rounds prices, that total can come to a little more than a plain conversion of yours. Other currencies has the detail.
Two other methods are for narrower cases:
- Variant matrix, when every priced choice is a dropdown, radio or checkbox and you want Shopify's own variants.
- Single line, on Shopify Plus, for the tidiest possible cart.
The fourth, Bundled parts, is an older method. It is described below for configurators that already use it; choose Product lines for a new one.
Product lines
The configured price is assembled from real cart lines: your product, the products the configuration links, the variants its parts pick, and hidden lines for the amounts 3D Bits works out. Each priced option gets a hidden line of its own, unless you choose one combined charge (below), and formulas, typed part prices and anything else 3D Bits calculates share up to three more.
Shopify prices your own products. Your product, every product linked to an option or a part, and every variant a part picks are charged at the price Shopify sets for them, in your currency, in other currencies and in every country. Change a price in Shopify and the configurator and checkout follow it, with no publish needed. 3D Bits works out only the rest: the amounts you set in the Composer. On the boat, Tender, 4 m is charged at whatever Shopify says it costs today, and the Sport helm's 28000 comes from the Composer. A project published before 3D Bits worked this way needs one more publish first - see Projects published before this change below.
At checkout the shopper normally sees one line at the full configured price: the extra lines are combined into it. The exception is a configuration that posts more than 2,000 units on one of those lines: Shopify will not combine a group that large, so the parts stay listed separately. Publishing warns you when a configuration of yours will do that. A configuration with a part picked from your variants checks out only as one combined line, so for it publishing stops instead and names the configuration.
In the cart that combining has already happened too, and the combined row carries none of the chosen options, so it would show a price with nothing explaining it. 3D Bits fills that gap itself with a configuration summary under the row, collapsed to a count and expanding to every choice with its swatch or thumbnail. The full list is on the order either way.
- Works on every Shopify plan
- Handles everything: options, formulas, sliders, parts, linked products, parts picked from your variants, quantities (set multiplier, purchase quantity and per option). Options, formulas, sliders and quantities work on every 3D Bits plan; parts, linked products and parts picked from your variants need the Pro plan
- Every part linked to one of your products, or picked from your variants, appears on the order as that product, so your team can see what to pick and make
- Your own products always cost what Shopify says, in every market and country
- Follows Shopify's price in a market that includes tax based on the shopper's country: every line is re-priced for the country, and the configurator shows the total the cart collects (Other currencies)
- Keeps a configuration together: in the cart your product and its parts normally make one row, which the shopper keeps or removes whole, and checkout refuses a cart that does not pay for every part
- Creates hidden helper products in your catalogue for the amounts 3D Bits works out (what they are)
- Needs the configurator's own Add to cart element, shown on every device: your theme's button adds the product without the lines its choices are charged through, and the cart refuses it. Publishing warns you when it is missing
Pick this for almost every configurator, whether you price with formulas or sliders or the configuration is made of products you already sell. Configurators Built From Products You Already Sell walks through the second case. If you sell in other markets, Other currencies says what shoppers there see and pay.
In this method the base price of the configurator is your product's own price in Shopify. Publishing stops if no variant of the product the configurator sits on costs the base price you set, and the project page can set the price for you. Other variants of the product may cost something else: the project still publishes, with a warning: a shopper who picks one of them sees and pays that variant's price in place of the base price. See Setting up pricing.
Projects published before this change
A Product lines project you last published before 3D Bits began charging your own products at Shopify's price keeps working the old way until you publish it once more: it charges the prices you published, and checkout refuses a cart when a linked product's price has moved since. The projects list marks such a project Republish needed.
That publish can stop for three reasons, each named in the message:
- No variant of your product costs the base price. Set one to match the other.
- A part that links a product is marked Already part of the base price. Untick it and lower the base price by what the part costs.
- A linked product is saved at two different prices. Sync the prices.
A Single line project with a linked option or part, or with a part that picks one of your variants, is charged through Product lines, so the same rules apply to it.
One line per option, or one combined charge
Product lines has a second setting, in the project's Storefront settings: How option charges reach the order. Bundled parts has it too.
One line per chosen option is the default. Each priced option gets its own hidden line, a variant of a hidden product made for its control, so the order itemises the options as separate lines - which is what you want when your workshop reads the order line by line.
One combined charge collects the priced options together instead, so the options take no lines of their own: a configuration adds at most three lines for them, however many options were chosen.
The trade-off is capacity. Checkout can check only so many lines in one cart, so a configurator with many priced options lowers how many configured items one cart can hold. Publishing tells you the number. If shoppers are hitting that limit, switching to the combined charge is the fix.
Either way, options linked to your own products still ship as their own lines, and the order still carries the full breakdown of what was chosen.
Bundled parts
An older method, kept for configurators that already use it. For a new configurator choose Product lines, which charges your own products at Shopify's price, follows every market and can charge a part picked from your variants - none of which this method does. The parts are the same real ones as in Product lines, reaching the cart a different way: the shopper adds one line, and Shopify nests the parts underneath it as a bundle.
How its room is counted. The whole cart may carry about 117 extra lines, shared by every configured item in it, which is what limits Product lines. A bundle is one line at checkout however many parts it holds, so its parts do not count against that. What limits a bundle instead is how much checkout may write when it nests the parts, counted as the parts one configuration can charge at once, as parts that exclude each other on the same choice do not count together: about 120 of them for one configured item, fewer as a shopper buys more of it in one cart. Single line charging, which nests nothing and carries no linked parts, is limited by the size of the rules themselves: a few hundred parts with typed prices, fewer the more conditions each carries. Publishing tells you when a project is over, and what is costing the most.
Holding the parts together is not a reason to choose it. Product lines does that too: it combines your product and its parts into one row in the cart, and checkout refuses a cart that does not pay for every part. Neither method lets a shopper check out half an assembly.
- Handles everything Product lines handles, except a part picked from your variants: options, formulas, sliders, parts, linked products, quantities. Parts and linked products need the Pro plan
- Every part linked to one of your products appears on the order with its own price, inventory and fulfilment row
- The bundle's price is the sum of what sits under it: the parts and option charges, plus one hidden Configured price line for the base price, formulas and typed part prices
- Charges every part at the price you published - after a price change in Shopify, publish again to sell at the new one
- In another country it charges your own country's total converted once: it does not follow tax that depends on the shopper's country, or a price you set for a linked product in a market's price list (Other currencies)
- Creates the same hidden helper products in your catalogue (what they are)
- A part that picks one of your variants needs Product lines, and publishing says so
- The configured product is a grouping, not a pickable line: your team picks the parts listed under it
- Not available for subscription or pre-order purchases (a Shopify restriction, shared with Product lines and Single line)
If a Product lines configuration runs out of room, Managing complexity lists what to change first.
Shopify caps how many of a single part one bundle may hold. Publishing works this out for your configurator: it refuses outright if one part already exceeds it, and otherwise checks it against your quantity control's own maximum. If that maximum lets a shopper ask for more than the bundle can hold, publishing stops and names the number to set it to; if the control has no maximum at all, it warns you. Lowering a part's quantity per set raises the number.
Each part is its own line item with its own price and inventory, labelled "Part of: your product". The configured product itself is the heading they sit under, and it carries the configuration, the preview image and the order PDF. Under the heading you also find one hidden line, Configured price, which carries the base price, formulas and typed part prices, and shows 0.00 when the other lines cover everything. The price breakdown, the parts list and the re-open link all work exactly as they do in Product lines.
Every part is priced individually, including each product an option links, so your per-product reporting is right. A product you linked without a recorded price shows 0.00, so keep your links' prices up to date. The order total is exact either way.
Variant matrix
3D Bits generates a real Shopify variant for every possible combination, on your own product. When a shopper configures, the storefront simply selects the matching variant.
- Native at checkout: checkout charges Shopify's own price for the variant in every market, and Markets and discounts apply untouched
- In another currency the configurator shows a plain conversion of your own price. Where a market adjusts or rounds prices, or has a price list, the shopper pays Shopify's price for the variant there, which can differ from the one shown, so compare the two in each market you sell in
- The generated variants are set to keep selling when out of stock
- In a market that includes tax based on the shopper's country, checkout charges the per-country price but the configurator still shows your own country's total - see Other currencies
- No helper products
- Only possible when every priced choice is a discrete option - no formulas or sliders
- Takes over the product's variants entirely. It needs a project linked to just one product, and a product with no variants of its own (only Shopify's default one); publishing stops otherwise
- Shopify caps variants per product, so very large combinations do not fit
Pick this if your options are all dropdowns, radios or checkboxes, the number of combinations is modest, and you want real Shopify variants charged at Shopify's own prices. The app lists it as Host variant matrix.
Choosing this method rebuilds the product's option space. 3D Bits will refuse if the product has variants it did not generate, so your existing variants are never silently overwritten - but you should expect the product to be about the configurator once you switch.
Single line
The configured product is charged as one line whose price is set to the configured total. The app lists it as Single line (Cart Transform).
- The cleanest cart: one line, no helper products at all
- Requires a full Shopify Plus plan, not a Plus trial (or a development store not set to try a lower plan)
- Requires the Standard or Pro 3D Bits plan
- Ignores your markets' rounding rules, percentage adjustments and per-country tax - in another currency it shows and charges a plain conversion of your total - so it suits single-currency, single-country stores better
A project with an option or a part linked to one of your products, or a part that picks one of your variants, is charged through Product lines instead, and publishing tells you so.
Pick this if you are on Plus, sell in one currency, and want the tidiest possible cart.
How many options each method supports
The limits differ sharply, and they are the main reason a method may not be available to you.
| Product lines | Bundled parts | Variant matrix | Single line | |
|---|---|---|---|---|
| Priced controls | No fixed limit | No fixed limit | At most 3 | No fixed limit |
| Options per control | No fixed limit | No fixed limit | Limited by the combination total | No fixed limit |
| Total combinations | Not enumerated - no limit | Not enumerated - no limit | At most 2,048 | Not enumerated - no limit |
| Formulas and sliders | not possible | |||
| Parts | a charged part is not possible | a linked part moves it to Product lines | ||
| A part picked from your variants | publishing refuses | not possible | moves it to Product lines | |
| An option linking several products | not possible | moves it to Product lines | ||
| A shopper-chosen quantity on an option | not possible | |||
| A set multiplier (Quantity control (optional)) | not possible | |||
| Multi-select checkboxes | not as a dimension | |||
| Parts one configuration can carry | about 117 linked ones, shared by every configured item in the cart | about 120 | not applicable | a few hundred with typed prices |
Why the matrix is the strict one. It generates a real Shopify variant for every combination, so it inherits Shopify's own product limits: 3 option dimensions and 2,048 variants per product. Four priced controls, or 3 controls whose options multiply past 2,048, cannot be expressed as variants at all.
Multiply your options to check: 3 lengths × 3 helms × 3 collections = 27 combinations, comfortably inside. The tutorial's boat also prices its Planks, a fourth control, so it could never be a matrix whatever the total.
Why Product lines has no fixed limit. It creates one hidden product per priced control and one variant per option, and splits a control across several products when it exceeds 250 options. So a control with 400 colours is fine.
There is still an overall ceiling: a configuration with a very large number of priced options and conditions can grow past what checkout can verify. Publishing refuses such a project and names the size - see Managing complexity. In practice this is far beyond what a shopper would sensibly navigate.
How Bundled parts is counted. A bundle is one line however many parts it holds. What limits it instead is how much the app may write when it nests the parts, counted as the parts one configuration can charge at once, as parts that exclude each other on the same choice do not count together: about 120 parts for one configured item in the cart, about 60 each when a shopper buys two of them, about 30 each for four. Publishing works that out for your configurator and tells you the number.
If your configurator cannot be a matrix, publishing says exactly why and uses Product lines instead rather than failing. It checks these in order, and names the first one it meets:
- A Quantity control (optional) on the Pricing tab, which multiplies the whole configuration.
- An option that lets the shopper choose a quantity.
- A priced control that cannot be a variant dimension - only dropdowns, radio buttons and checkboxes can be.
- An option that links your own products - one or several - since they must reach the order as their own lines.
- Any charged part - a linked one is a real item needing its own line, and a priced unlinked one is an amount rather than a variant.
- Any formula, which produces amounts that cannot be enumerated.
- A multi-select control, since a variant holds one value per option.
- No priced option controls at all to build a matrix from.
- More than 3 option dimensions, which is Shopify's limit.
- More than 2,048 combinations, which is also Shopify's limit.
How many configured items fit in one cart (Product lines)
With Product lines charging, every product a configuration adds - linked to an option, linked to a part or picked from your variants - is a cart line of its own, and so is each priced option unless you combine option charges; formulas, typed part prices and combined option charges share up to three more. Checkout can check only so many lines in one cart, shared by every configured item in it. Publishing counts the most lines one configuration can add beside your product, and that sets how many configured items one cart holds:
| Lines one configuration adds | Configured items one cart holds |
|---|---|
| up to 29 | 4 |
| 30 to 39 | 3 |
| 40 to 58 | 2 |
| 59 to 117 | 1 |
| more than 117 | none - publishing stops |
A part picked from your variants takes a little more room than other lines. A configuration made only of such parts holds:
| Parts picked from your variants in one configuration | Configured items one cart holds |
|---|---|
| up to 25 | 4 |
| 26 to 33 | 3 |
| 34 to 50 | 2 |
| 51 to 101 | 1 |
| more than 101 | none - publishing stops |
Very many choices or text fields, long price formulas, long lists of parts, or product names longer than about 200 characters can hold a cart to fewer. Publishing always tells you the number, and a shopper who tries to add more is told how many fit - see Troubleshooting.
Choosing
| Your situation | Method |
|---|---|
| Just getting started | Product lines |
| You price with a slider, a formula, or by area or length | Product lines |
| The configuration is made of parts you also ship | Product lines |
| One choice adds several of your own products | Product lines |
| A part is one of your variants, picked by the shopper's choices | Product lines |
| Your store already sells every combination, as variants | Product lines - see Products you already sell |
| You sell in markets that include tax based on the shopper's country | Product lines - see Other currencies |
| You sell in other currencies, or in markets that adjust or round prices | Product lines - see Other currencies |
| The parts must stay together, so nobody orders half an assembly | Product lines |
| The configuration adds more cart lines than publishing allows, or one cart holds fewer configured items than your shoppers buy | Product lines, with fewer lines - see Managing complexity |
| All options are discrete, the combinations are few, and you want real Shopify variants | Variant matrix |
| You are on Plus, sell in one currency, want the tidiest cart | Single line |
| More than 3 priced controls, or more than 2,048 combinations | Product lines (the matrix cannot express it) |
Changing your mind
You can switch methods and republish. 3D Bits cleans up after the method you left - archiving helper products it no longer needs, or restoring your product to a single variant when you leave the matrix.
Four things to know before you switch:
- Archived, never deleted. Past orders point at helper products, so they are archived rather than removed. See Helper products.
- After leaving the variant matrix, check your product's price. The matrix replaced its original variants, so 3D Bits restores it to a single variant priced at your authored base price, or at the cheapest combination it had generated if there is no base price - which may not be the price you want.
- Moving between Product lines and Bundled parts changes nothing in your catalogue: both charge through the same helper products and the same linked products. What changes is the cart, the order's shape and how many parts a configuration may carry. Moving to Product lines can therefore be refused if the configuration has grown past what it can publish, and the message says so.
- A cart built before the switch cannot be checked out. The two methods build different carts, so a shopper who added your product days earlier is asked to remove it and configure it again rather than being charged twice. Nothing is lost - only that shopper's in-flight cart is affected, and only until they re-add it.
If a method you picked is not available to your store or your configuration, publishing tells you and usually uses Product lines instead rather than failing. Single line is the exception: when the app cannot switch on the checkout function it charges through, publishing stops, as the product would otherwise sell at its own price. Pricing conditions written in the expression editor cannot run at checkout under any method; publishing names them so you can rewrite them in the visual condition builder.
Product lines is the fallback, so it has none of its own. When it cannot be set up either, publishing stops rather than going live with a configurator that would collect the wrong amount.
Bundled parts has no fallback either. Nesting the parts is what charges the order, so if the app cannot set that up on your store, publishing stops and says so rather than going live with a product that would collect its own price and ship none of its parts.
Verified against the product in November 2026