Skip to content
Kitenzo Headless
Kitenzo Headless is invite-only. To enable it on your store, email support@kitenzo.com.

Kitenzo Headless · API v1

Bundles for any storefront. Same engine as your theme.

A REST API, a typed TypeScript SDK and a drop-in web component that read the bundles you built in Kitenzo — and hand you exactly what to send to the Shopify cart. Rules, pricing, validation and checkout discounting stay on the engine that powers your theme.
Get started Explore the API
  • REST API v1
  • @kitenzo/react 0.4.0
  • Shopify-native checkout
  • Hydrogen · Next.js · TapCart
Hydrogen / Remix Storefront API cart, SSR loaders Next.js & React Provider, hooks, local pricing TapCart mobile appsNew Custom block, cart-ready payload Any HTTP client Vanilla JS, Vue, Svelte, server-side

How you build

Embed the full UI, or own every pixel.

Two integration modes, one API, one key. Both read the same bundle definition and end in the same Shopify-native checkout.

Mode 01 — Embed

The full UI, zero UI code

The same admin-configured experience your Liquid theme renders — templates, conditions engine, limit rules, tiered discounts — mounted in your storefront.

web component
<link rel="stylesheet" href="…/bundle-builder-bundle.css">
<script src="…/bundle-builder-bundle.js" type="module">

<bundle-builder-bundle-v1
  id="42"
  api-key="kit_live_…"
  prefix="https://live.bb.eight-cdn.com/api/headless/v1/embed">
  • Web component, React BundleEmbed, or vanilla createBundleEmbed
  • Intercept kitenzo:addtocart and write the cart yourself
  • Merchants restyle it from the Kitenzo admin, not a release
Embed guide →

Mode 02 — SDK · Recommended

A custom UI on our engine

Typed hooks for selection state, validation, local pricing and cart compilation. You write the interface in your design system; Kitenzo runs the rules.

@kitenzo/react0.4.0
import { useBundle, useBundleBuilder,
         useBundlePrice, useBundleCart }
  from '@kitenzo/react'

const { bundle } = useBundle(bundleId)
const { addItem, isSatisfied, errors } =
  useBundleBuilder(bundle)
const { formattedDiscountedPrice } =
  useBundlePrice(bundle, selections)
  • Your code, your repo — no lock-in to a template
  • addBundleToCart writes lines + _bundles in one call
  • Conditions engine and Shopify Markets pricing built in
SDK guide →

New — Native mobile

Bundles inside a TapCart app

TapCart replaces the theme, so Liquid bundles never reach the app. Call /configure from a custom block instead: it returns a cart-ready payload — line items carrying _bundle_data plus the _bundles attribute — that you hand straight to TapCart's cart actions. Checkout runs Shopify's real web checkout in the native sheet, so Cart Transform prices the bundle exactly as on the web.

TapCart guide →
tapcart custom blockcart-ready
// inside a TapCart custom block
const { cart } = await configure(42, picks)  // POST /bundles/42/configure

Tapcart.action('cart/add', {
  lineItems: cart.line_items.map(toTapcartLine)  // _bundle_data on every line
})
Tapcart.action('cart/updateAttributes', {
  attributes: mergeBundles(cart.attributes)      // merge, never overwrite _bundles
})
Tapcart.action('cart/checkout')                  // Cart Transform prices it

The engine

Build any bundle experience without rebuilding bundle logic.

You design the experience. Kitenzo tells you what's possible, what it costs, and exactly what to send to Shopify.

Things you never implement again

  • Selection state, section limits and required-product validation
  • Bundle price, discount and tier calculations — locally, with no round trip
  • Server-side price verification before checkout
  • Cart line encoding and the _bundles cart attribute
  • Discounting at checkout, via a Shopify Cart Transform function
  • Keeping theme, Hydrogen and mobile on one shared engine
headless apiv1
GET  /bundles
GET  /bundles/{id}
GET  /bundles/{id}/products
POST /bundles/{id}/price
POST /bundles/{id}/configure
GET  /settings
Authenticated with a publishable key, scoped to the origins you allow. Prices can be verified server-side before you configure, and every configured bundle checks out through Shopify Cart Transform.
Full endpoint reference →

How it works

From API key to checkout in four steps.

No proxy to run and no webhook choreography — the SDK and the embed talk directly to the API, and the cart contract is three keys on a Shopify cart.

  1. 01

    Request access

    Headless is invite-only. Email support@kitenzo.com and we enable it on your shop.

  2. 02

    Create a key

    Generate a publishable kit_live_… key in Settings → Headless, scoped to the origins you allow.

  3. 03

    Read & build

    Fetch bundles over REST or the SDK and render your own UI — or drop in the embed and render nothing at all.

  4. 04

    Configure & check out

    Submit the selection, write the returned lines and _bundles attribute to the Shopify cart, and Cart Transform applies the discount at checkout.

The data layer

Everything your bundles know, over one API.

Structure, live pricing and rules, read straight from the engine that powers your Liquid storefront.

Bundles, sections & variants

Published bundles, ordered steps, live variant pricing, SKUs, options and inventory.

Read more →

Discounts

Flat and tiered discounts — percentage, fixed or fixed-price — with thresholds and operators.

Read more →

Limit rules

All eight rule types that decide what counts as a valid bundle, section-scoped or bundle-wide.

Read more →

Required products

Items every configuration must include, appended and validated on submit.

Read more →

Conditions & subscriptions

The conditions-engine rule graph and live selling plans, evaluated client-side by the SDK.

Read more →

Bundle types

Native, single-product and multiple-products — and how each one reaches the cart.

Read more →

Worth knowing

What we'd want to know before we started.

Access is granted, not self-serve

The headless API is enabled per shop. Talk to us and we turn it on, mint your keys and set the allowed origins with you.

The discount lives at checkout

For native bundles the Cart Transform reads the _bundles cart attribute. Skip it and the bundle rings up at full price — the SDK and the /configure cart payload both write it for you.

Versioning

The REST API is v1 and stable. The npm packages are pre-1.0 and follow semver — pin them and read the changelog before upgrading.

Tell us what you want to build.

We'll enable Headless on your shop, mint your keys, and walk your team or your agency through the first build.

Request access Read the quickstart →
  • One bundle definition
  • Any storefront
  • Shopify-native checkout