Changelog

Calling cartProcess again for a cart whose items have not changed since it was processed returns the order it already created instead of placing a second one, so a checkout that timed out can be retried safely. When pricing is temporarily unavailable, cart calls fail with PRICING_UNAVAILABLE_ERROR, which you can retry after a short wait, while FETCH_PRICING_ERROR now only means that a line cannot be priced.

Product search treats categoryId: 0 as a filter for the products and clusters that are not in any category. Before, a 0 was ignored and the search returned the same results as one without a category filter. If you send 0 to mean all categories, leave categoryId out instead.

Product filters are built from at most 200 attribute descriptions, so with more searchable attributes than that the filters list can come back incomplete or even empty. The new filterCoverage field next to filters shows how many attributes matched and whether the limit left any out. To get filters for specific attributes regardless of the limit, pass their IDs in the ids input of filters.

pricesheetUpdate and PATCH /v2/pricesheets/{id} accept the assignment fields companyIds, contactIds, customerIds and usergroups, plus the source variants companySources, contactSources and customerSources. A field you send replaces the current assignments of that type and an empty array clears them, while a field you leave out keeps its assignments. To add or remove single assignments, keep using pricesheetAssign and pricesheetUnassign.

The new priceCalculateBulk query prices up to 5,000 combinations of product and quantity in one request, for one Contact, Customer or Company in one tax zone. Each line comes back with either a price or an error, so a product that cannot be priced does not fail the others. Use it instead of many separate priceCalculate calls, for example to price a quick order form.

Order search now splits term into words and returns the orders where every word matches one of the searched fields, where before the whole term had to match as one phrase. Words need 3 to 255 characters and only the first five count, while a number of any length matches the order ID exactly instead of as part of it. A term without any usable word, such as ab, is now rejected with a validation error instead of returning results.

Order search takes an ids filter in both APIs, so you can fetch orders you already know in one request instead of one request per order. IDs that do not exist or that you cannot access are left out of the result instead of failing the request.

Requests for carts, checkout, orders, stock, surcharges and favorite lists were rejected once their body passed 100 KB, so orders with many lines or large stock updates could fail, sometimes with an unclear error. The limit is now 1 MB, or 3 MB for orders.

The nextDeliveryDate of an inventory record now comes back as a full UTC timestamp, for example 2026-04-01T00:00:00.000Z. Before, the time zone was left off (2026-04-01T00:00:00), so it could be read as local time instead of UTC.

Inventory records take two new quantities from your ERP: allocatedQuantity for stock that is sold but not yet shipped and expectedQuantity for stock that is purchased but not yet received. From them each record derives freeQuantity (the stock you can still promise) and economicQuantity, while a product's inventory adds totals for all four plus nextExpectedDeliveryDate for stock that is actually on its way. A quantity your system does not report stays null instead of counting as 0, so the derived figures only use numbers you actually sent.

The prices of all lines in a cart are now calculated together, so adding items to a cart with many lines and checking it out is faster. Product queries that select surcharges for many products at once are faster too.

Adding items to a cart failed once it held about 1,000 lines, with the exact number differing per tenant. Carts can now grow past that and orders of that size can be opened again for editing.

When cartItemBulk, cartUpdateItem or cartDeleteItem fails because the cart cannot be recalculated, the change is undone and the cart stays as it was. Before, lines from a failed cartItemBulk call stayed in the cart without showing up and made every later change fail. A failed cartItemBulk call lists the lines it undid in extensions.rolledBackItemIds, while an itemId the cart does not hold is rejected with CART_ITEM_NOT_FOUND_ERROR before anything is written.

New mutations delete many records in one request: productDeleteBulk, categoryDeleteBulk, companyDeleteBulk, contactDeleteBulk, companyAddressDeleteBulk and customerAddressDeleteBulk, with matching bulk DELETE endpoints in the REST API. A record that cannot be deleted does not stop the rest of the batch: the response lists it with the reason, for example a Company that still has Contacts.

Requests made with an API key and no user token can pass the channel's anonymousUserId as userId in products and category.products, so orderlists assigned to the anonymous user are applied. Before, products rejected this with "Unauthorized use of userId" and category.products returned an empty page. When the products of a category cannot be loaded, the response now reports an error for that category instead of an empty page.

roleDefinitionUpdate created a new role definition at the id you passed when nothing had that id, so a stale or mistyped id produced a phantom record rather than an error. roleDefinitionUpdate, roleUpdate, roleDefinitionDelete and roleDelete now return a not-found error when the target does not exist.

orderStatusSetUpdate returned orderStatuses as null whenever the input left orderStatusIds out, so an update that changed only the name or the priority reported the set as holding no statuses. An update now returns the statuses in the set whichever fields you change. This matters most for clients with a normalizing cache, where that null was written over the cached set and then read back by unrelated queries.

Order search takes a validUntil filter in both APIs, so you can select quotes by the date they stay valid until. It works like the other date filters and accepts greaterThan and lessThan. Use it to pick up quotes that are about to expire or have already lapsed, instead of reading every order and filtering in your own code.

The discount field on an order item is an absolute amount per unit in the order's currency and never a percentage. Both APIs now state this on the field itself, along with how it is calculated (originalPrice minus price, including any item incentive) and how to derive the percentage from it. The order level total.discountValue behaves differently: it is absolute or a percentage depending on total.discountType.

Processing a cart could fail with "Failed to fetch pricing" once it held enough lines, which put a practical ceiling on how large an order could be. That ceiling is gone. When a line cannot be priced, the error now points at that line rather than failing the whole order.

Moving products into a cluster and then deleting the product the cluster started with could hide the cluster and its products from every listing and every search, even though the catalog still held them. Deleting a cluster could leave its products behind in search results instead, which made listing pages arrive short or empty. Listings and search now match the catalog after either change.

Several cartAddItem calls fired at once against the same cart used to answer success for every call while most of the lines were quietly missing from the resulting cart. A cart now takes one item write at a time and rejects a second concurrent write with CART_CONCURRENT_WRITE_ERROR, which also covers cartUpdateItem, cartDeleteItem and cartItemBulk. To add many lines at once, send a single cartItemBulk rather than a burst of separate calls.

OrderStatusSet now has a priority field, following the same convention as the priority on an individual order status. Use it to order the sets directly wherever you group orders, quotes or requests by status, instead of deriving an order from the statuses each set contains.

Adding a product the catalog will not sell to the current Contact, Company or Channel returned a cart with the product quietly missing and no field to check, so a storefront could not tell a successful add from a dropped line. Such a product is now returned under unOrderableItems on the resulting cart instead of under items, so you can detect it and tell the customer why. A line that reaches neither list now fails with CART_ITEM_ADD_ERROR rather than returning a cart with the product silently absent.

A contact can now read and change a cart that belongs to another contact in the same Company. Until now a cart was reachable only by the contact who created it, so there was no way to build a shared basket, hand a cart to a colleague for approval or let a buyer finish an order someone else started.

Access is bounded by the Company: contacts see each other's carts only within the Company they are acting for.

A quote line could report a discount of 0% even though the discount had been applied correctly and the line price already reflected it. The percentage on the line now matches the discount that was applied, so a quote you render or export shows the same figure the customer pays.

Order handling expected packageUnitQuantity to be a whole number, while creating a product stores it as text, so an order carrying a product with that field could fail. Order handling now accepts the value in the form products are created with.

Orders and order lines can now carry attributes, the same way products, companies and contacts do. Define an attribute description once, then set values per order or per line to hold whatever your process needs: a cost center, a delivery instruction, a project code or a reference your ERP expects back.

Values are set while the order is still a cart or a quote and carry through to the order. cartAddItem, cartUpdateItem and the bulk cart item operation all accept attributes on a line, tender items accept them too, and both Order and OrderItem expose an attributes field when you read the order back.

An action code applied to an order was not stored on the order or returned by the REST order endpoints, so an integration reading orders could not tell which promotion had been used. The action code is now persisted and exposed on the order.

cartUpdateItem returned the same generic CART_ITEM_UPDATE_ERROR whatever went wrong, so a client could not tell a cart that no longer exists from an unknown item or an attribute that is not defined on the tenant. The mutation now returns the specific error for each cause, matching what cart and cartAddItem already reported, so you can decide whether to re-resolve the cart, correct the input or surface a configuration problem without an extra query.

Carts are now available over REST as well as GraphQL, at /v2/carts for creating a cart, /v2/carts/{id} for reading, updating and deleting one, and /v2/carts/search for finding carts. This suits an integration that builds or inspects carts from a backend system, where the rest of the work already runs over REST.

Frontends should keep using the GraphQL cart operations, which stay the recommended path for storefronts.

An order containing a free bonus item reported more VAT in its breakdown than the order total accounted for, so the two did not reconcile. Free bonus items are now excluded from the VAT breakdown, and the breakdown adds up to the order total again.

If a channel's anonymous user had a positive orderlist assigned, cluster indexing stopped for the whole tenant and no error was raised. New and updated Clusters never reached the search index, so cluster search returned nothing and catalog listings showed counts without rows, while product indexing carried on normally. Cluster indexing no longer applies the anonymous user's orderlist, so restricting the anonymous catalog with a positive orderlist is safe again.

An API key can now be marked at creation as retrievable only once. The full key value is returned in the creation response and cannot be read again through GraphQL or REST afterwards. Store the value when you create the key, because there is no way to recover it later.

In a large bulk product import, the skipMoveOnUpdate directive could be applied to only part of the batch, so products that had been organized into other categories were moved back to the category in the payload. The directive now holds across the whole batch regardless of its size.

Adding several products to a quote in a single call could return the wrong Cluster against a product, because the cluster rows were paired to products by position rather than by identifier. Products added together from different Clusters now each keep their own, so grouping and cluster options on the quote are correct.

Reading an orderlist that had tens of thousands of users assigned to it could fail with a service error rather than returning a page of results. Orderlists of that size now page through their members as expected.

A bulk price import failed in full when a single record referenced a source that could not be resolved, so valid records in the same batch were not written either. Source resolution now tolerates a record it cannot match, and the rest of the batch imports.

The orders query can now search on company name. Pass COMPANY_NAME in termFields alongside a term to match orders on part of a name, so "Consul" finds orders for "Consultancy Group". The value comes from the linked Company and follows renames, unlike the company names captured on the invoice and delivery addresses, which stay as they were when the order was placed.

Product descriptions copied onto an order could be taken in the wrong language, so a document such as an invoice showed a description in a language the customer does not read even though their language was set correctly. Descriptions now follow the language on the account the order is placed for.

A business rule can now be limited to one or more channels, so a shipping cost, carrier, payment method, incentive or transaction cost rule applies only where you intend it to. The scope covers the whole rule including its subrules, and it is matched against the channel of the cart or tender being evaluated. Rules without a channel scope apply to every channel in the tenant, so existing rules keep working unchanged.

Error responses from the company, contact and customer endpoints no longer include the moreInfo field. It carried a generic restatement of the error category rather than anything specific to the request. Read type for the error category and messages for the details of what went wrong.

Importing pricesheet discounts from a CSV file returned an error for files that matched the documented format, and the message did not indicate what to change. Files in the documented format now import.

A company name containing an ampersand was stored with the HTML entity & in place of the character, so a name such as H&A was saved and returned as H&A. Ampersands are now stored and returned as entered.

When a record in a bulk company import was skipped because it held no changes, the success and action fields in the per-record response did not report that consistently, so a skipped record could read as a failure. Skipped records now return a consistent result you can rely on when checking the outcome of a batch.

Attribute values set on companies, contacts and customers through the bulk endpoints were stored on the account but not passed on to pricing, so a pricesheet assigned by user group did not apply to accounts imported that way. Setting the same attribute in Backoffice did work, which made the difference easy to miss. Bulk attribute changes now reach pricing, so imported accounts get the prices their group entitles them to.

ProductSearchInput now accepts an inventory filter with totalQuantity, localQuantity and supplierQuantity, so you can limit a catalog listing to products above or below a stock threshold instead of fetching everything and filtering in your application. The filter is applied server-side, so itemsFound and the page count match the filtered result set. Queries that do not send the filter behave as before.

On catalogs that use price sheets, product search returned minPrice and maxPrice as 0 and did not order results correctly when sorting by price. Both the price filter and price sorting now use the price that applies to the requesting customer, so a price slider and price sort work on a catalog page with customer-specific pricing.

A Cluster assigned to a hidden Category still appeared in the product listing of a parent Category when the Cluster's own Category resolved to a visible one. Products in the same hidden Category were already excluded. Hidden Categories now suppress Clusters in the same way, so a hidden branch of the catalog stays out of listings.

When a product search was filtered on an enum attribute, the filter was applied to the results but every value in the returned facet came back with isSelected: false. Facets now mark the applied values as selected, so a filter panel that binds its checkboxes to that field shows the active selection.

When the products query received a companyId without a userId, Orderlists assigned directly to that Company were ignored and the full catalog was returned. Orderlists are now resolved from companyId on its own, so a positive Orderlist restricts the results to its products and a negative one excludes them.

The bulk inventory endpoint accepted companyId but ignored it, so a record meant for one company's stock was written to general stock instead and the response still reported success. Company-specific records are now created and updated as sent, and general stock is left untouched.

favoriteListCreate returned a 403 Forbidden error when called with an owner-scoped API key, whether the list was scoped to a contact, scoped to a company or had no owner. Owner-scoped keys can now create, read, update and delete favorite lists, including company-owned ones. Keys without that role still receive a 403.

CartSearchInput now accepts a references filter, so you can look carts up directly by the reference your application set with cartUpdate, and pass several references in one call. Previously, finding a cart by reference meant fetching a company's carts and matching the value client-side.

An API key with elevated product rights could search every product in the tenant, but adding one to a cart failed unless a catalog root was set on the key's channel. Cart operations now follow the key's product access, so such a key can add any product in the tenant, including products outside its own channel. Keys without those rights stay restricted to their channel.

Importing discounts in bulk through the REST API could fail with an error, or create an invalid discount, when a record referenced a product that does not exist in the catalog. Those records are now skipped, so the rest of the batch imports without needing to check first whether each product exists.

You can now create cross-sell and upsell relations in bulk with a single REST request, instead of one call per relation. Items can be matched by product ID, product UUID or a source and source ID pair, and the response reports the result for each item. This brings cross-sell and upsell in line with the bulk import already available for products, categories and prices.

A new REST endpoint imports product videos in bulk, mirroring the existing bulk image import. This makes it easy to attach many video links, such as YouTube URLs, to products at once.

Querying a machine's spare part products could return an empty list even when the machine had parts. The parts are now returned as expected.

You can now search value set items by their localized description text, as a case-insensitive partial match across all languages, instead of only by the value code. Special characters such as %, _ and \ in a search term are matched literally.

On the REST product search endpoint, passing expands=categories had no effect. The parameter now correctly includes category information in the results.

Fixed the JSON-LD structured data for products and clusters, correcting the type, the fallback image, the price formatting and the availability markup.

Creating or updating a product attribute value did not always update the matching search facet filter, so faceted search could show stale values. Attribute changes now appear in the facets in near-realtime, without a manual reindex.

The order detail page now shows each item's shipment status as a translated, color-coded badge, with a status column in the item overview and Unknown shown when a status is missing.

Assigning users or companies to an order list, or adding items to it, through the REST order list endpoints could fail with a server error. These endpoints now work as documented.

The ICS surcharge flag is now added to a cart address only for logged-in contacts, not for guests or other user types.

You can now search companies, contacts and customers by a free-text term. An empty term is handled gracefully instead of returning an error.

Quick order prices are now calculated from the logged-in customer's pricing instead of a fixed tax zone, so the listed prices match the customer.

The GraphQL query for companies has been optimized. Fetching large pages of companies together with their contacts, addresses, sources and attributes is now significantly faster.

Querying attributes on a cluster product could fail the entire query with a server error when an attribute had no value. The query now succeeds instead of erroring.

The generated XML product sitemap now includes only products within the configured catalog root.

When an order moved from draft to new, the address code in the REST order response could be truncated, which could break downstream exports. Address codes are now returned in full throughout the order lifecycle.

The validateOrderList flag on the tender item inputs (TenderAddItemsInput and TenderUpdateItemInput) is deprecated. It has no effect, because order lists are not enforced when adding or updating tender items regardless of the flag.

Product and cluster detail pages no longer return a 404 for logged-in B2B users, because the queries now include the user's company and contact context.

The bulk image import endpoint can now match products by their external source and source id (productSource and productSourceId), so you no longer need to resolve an internal product id first.

The GraphQL schema descriptions for the net and gross price fields were reversed relative to the values the API returns. The descriptions now match the API, so the reference describes each field accurately. The returned values themselves are unchanged.

A regression made language codes on localized fields such as product names, short names, package descriptions and slugs case-sensitive, so mixing lowercase and uppercase codes could produce empty values on import. Language codes are treated case-insensitively again, so nl and NL are equivalent across stored data, display and API responses.

Searching for a decimal value such as 130.1731005 could fail, and is now fixed. Single-character words and numbers in a search term are ignored and do not refine the search, because the minimum length for a search token is two letters or numbers.

Adding a cluster combination to the cart now submits the correct bundle id, so the item is added successfully.

Adding or updating a cart item no longer errors when the backend returns an empty response.

When a login is rejected because the account must set a new password, the storefront now shows reset instructions and automatically triggers a password-reset email instead of a generic login error.

Removing a contact from a company and then adding it back could fail because the earlier link was retained internally. Contacts can now be removed from and re-added to a company reliably.

Importing categories could fail silently when the description or short description contained HTML or was very long. These descriptions now import correctly.

The bulk shipments endpoint now upserts on the source and sourceId combination. A shipment with a known combination is updated and a new one is created when it does not exist yet.

Updating a product through the bulk upsert by source id did not save changes to eanCode, package and packageUnit. These fields are now updated as expected.

Searching orders through the API could return incorrect or incomplete results for some filter combinations. Order search now returns the orders that match the query.

Changing the supplier on an order item while editing a quote or order was lost once the order was processed. The updated supplier is now stored on the order.

Media items returned incorrect values for their created and last modified timestamps. These now reflect the actual creation and modification times.

Bonus item discounts were not always applied correctly. Incentive results are now calculated and stored consistently on the order.

The orders and quote queries now return the name of the company an order belongs to. This is the company itself, not the company name stored on the order address, which can differ.

Creating a category with a parent that cannot be found returned a confusing message with a second, unrelated line about root categories. The endpoint now returns a single clear message that names the missing parent.

Sending productSource as an array on the bulk prices endpoint failed with a not-found error, while a single object worked. The endpoint now accepts productSource as an array as well.

Bulk cost prices now support a from and to validity date, the same way bulk prices do. Use them to schedule a cost price change ahead of time.

The bulk import for companies, contacts and customers now accepts attributes in the same nested payload. You can set attribute values during the import instead of sending a separate request.

Creating an attribute description no longer requires a default value. Leave it out for attributes that do not need one. This applies to both the GraphQL and REST APIs.

The combo deals section on a product page no longer errors when the product has no bundles.

Clusters (product variants) have options, the extra products you offer alongside the configured cluster product. A product can now be linked to any number of clusters as an option instead of exactly one, which helps when the same product fits several clusters. The same product can still be sold on its own alongside those cluster offerings.

The product, category and cluster endpoints (including cluster configs, cluster options and cluster products) now have stricter, more consistent validation across REST and GraphQL, with clearer error messages. Lookup keys are case sensitive (use sourceId, not sourceid), and bulk requests reject duplicate identifiers and empty arrays, with each batch rolled back if an item fails validation. Categories, products and clusters created without a parent are kept as root or floating items rather than placed under a default category.

The price fields that were deprecated earlier have now been removed from the product and cluster-product endpoints (price, taxCode, taxPercentage, costPrice, suggestedPrice, discountPrice, discountPriceFrom, discountPriceTo, costprices, surcharges and priceDisplay); use the pricing endpoints instead. Cluster options also have their own dedicated input and response types.

The pricesheet CSV import treated localized name and description columns with the wrong type, causing valid rows to fail mapping. The import now accepts these columns as expected.

You can now set the order of categories, and of the products inside a category, per storefront. Categories and individual products can also be hidden without unpublishing them, which keeps seasonal or less relevant items out of view while preserving their data.