CAD to Web · 3D Viewer
3D Product Configurator APIs: Plugging a Headless Configurator Into Your Stack
By Gauri Nimbalkar · 17 November 2026

Most pages labelled "3D product configurator API" describe a player SDK. Platform and CPQ teams need a headless contract instead. That contract owns configuration state, validates rules, returns price and asset bindings, and hands a durable ID to ERP, CRM, or Shopify.
A 3D product configurator lets a buyer change options on a live 3D model and push that choice into price, quote, BOM, or order. This guide covers the API and integration side of that system. The Three.js SaaS tutorial owns front-end scene code; here we stay on contracts, auth, assets, and eventing.
Self-serve buying is not optional context. Gartner's March 2026 sales survey found 67% of B2B buyers prefer a rep-free experience (Gartner). That preference only works if the configurator API is trustworthy enough to feed order systems without a human re-keying options.
Key Takeaways
- A 3D product configurator API is a headless contract: configuration state, server-side validation, pricing/quotes, versioned glTF bindings, and lifecycle webhooks — not a canvas wrapper.
- The browser is a client. Final rules and price belong on the server; re-validate before every quote and order accept.
- Auth splits public vs private: domain-scoped public tokens for embeds; private tokens only behind a BFF. Scope every row by tenant.
- Deliver meshes from a CDN as compressed glTF/GLB (Draco, KTX2). Configuration responses return asset URLs and revisions, not raw mesh bytes.
- Platforms expose four shapes today — composable client API (Threekit), embed Web API (Mimeeq), data API + apiKey (3D Cloud), host callbacks (Vividworks). Custom headless wins when CAD, multi-tenant CPQ, or ERP owns price.
What a 3D product configurator API must expose
A production configurator API must expose five capability groups. Those are catalog context, mutable configuration state, validation, pricing or quotes, and asset bindings plus lifecycle events. If your "API" only sets attributes on a loaded player, you have a UI helper — not an integration contract.
Treat these as the minimum surface. Names vary by vendor; the jobs do not.
| Capability | Typical operations | What it returns |
|---|---|---|
| Catalog / context | Resolve product, market, currency, tenant | Attribute schema, defaults, metadata |
| Configuration state | Create, patch options, load by ID | Canonical configuration + revision |
| Validation | Dry-run option change or full check | Allowed options, errors, derived values |
| Pricing / quote | Price snapshot or frozen quote | Amount, currency, validity, line items |
| Assets | Resolve visuals for current state | Versioned glTF/GLB (and map) URLs |
| Lifecycle | Subscribe / deliver events | Signed webhooks to ERP, CRM, cart |
A typed configuration document is the commercial handoff. Screenshots help support; they do not replace a re-playable state object.
interface Configuration {
id: string;
revision: number;
tenantId: string;
productSku: string;
market: string;
options: Record<string, string | number | boolean>;
assetBindings: {
glbUrl: string;
contentHash: string;
lod?: ("high" | "med" | "low")[];
};
status: "draft" | "validated" | "quoted" | "ordered";
}
interface PriceResult {
configurationId: string;
revision: number;
currency: string;
total: number;
lineItems: { sku: string; qty: number; unitPrice: number }[];
validUntil?: string;
priceBookVersion: string;
}
Display attributes for building forms are necessary but not authoritative. Checkout, CRM, and manufacturing should only accept a configuration ID that the server has validated and priced.
Headless architecture: UI client, config service, commerce truth
Headless means three systems, not one player SDK. The configuration engine is independent of any one storefront UI. The browser (or native shell) renders; a config service owns rules and state; commerce or ERP remains the system of record for money and fulfillment.
The embed is not the API. Teams that only wire
postMessageor agetPricesCallbacklearn this late. CRM and ERP need a durable configuration revision and a re-validation path. Treat the player as a thin client of the config service.
Use a backend-for-frontend so private credentials never reach the browser. The host page may hold a public, domain-allowlisted token for read-mostly player work. Mutations that touch price books or order creation go through your server.
For how the render layer loads glTF and applies swaps, stay in the Three.js configurator architecture guide. WebGL 2 remains the commercial delivery surface, with global support around 95.73% as of late 2026 (caniuse WebGL 2).
Auth, multi-tenancy, and embed boundaries
Public tokens belong in embeds; private tokens belong behind a BFF. Authenticate reads for embeds with constrained public credentials, and keep private credentials on the server. Isolate every configuration, catalog item, and price book by tenant so multi-tenant SaaS cannot leak state across orgs.
Industry platforms already draw this line. Threekit documents public tokens for third-party website embeds (minimum permissions, domain allowlists, CORS enforcement) and private tokens for broader REST use from the server (Threekit tokens; REST auth notes). Bearer tokens created in an org are scoped to that org. That pattern is a good default whether you buy Threekit or build custom.
Practical rules for a custom headless stack:
- Public token — load schemas, assets, and non-sensitive configuration reads inside an allowlisted origin.
- Private token / service account — validate, price, persist quotes, register webhooks — only from your BFF.
- Tenant ID on every write — reject cross-tenant configuration IDs even if the token is valid.
- Embed isolation — iframe + origin-checked
postMessagewhen host CSS or scripts are untrusted; web component when you control the host.
Client-side scene cloning (so two products on one page do not share materials) belongs in the front-end guide. The API obligation is simpler: never return another tenant's catalog or price book, and never accept a configuration ID outside the caller's tenant.
glTF asset delivery and cache keys
Serve meshes from a CDN as versioned glTF/GLB URLs — not raw bytes in the config response. Configuration responses should return versioned asset URLs; a CDN should serve compressed glTF/GLB. Do not push mesh bytes through the pricing service, and do not treat a one-off file drop as the binding between options and visuals.
glTF 2.0 / GLB is the runtime format for web configurators. Draco or Meshopt shrink geometry; KTX2 or Basis textures keep GPU memory down — the same delivery defaults used across this cluster's build guides. LOD variants can be separate URLs selected by device class.
What the API owes the client:
- Stable product IDs mapped to content-hashed GLB URLs (
.../chair-v3-a1b2c3.glb). - Material or part map URLs when options swap textures without reloading the whole mesh.
- Cache headers that allow long CDN TTL on immutable hashes, and short TTL (or signed URLs) for private catalogs.
- Revision alignment — if rules change which mesh a SKU resolves to, bump the configuration's asset binding so stale tabs cannot order yesterday's geometry.
CAD-to-web preparation (tessellation, UV, PBR, compression) is the critical path for many industrial catalogs. That pipeline is scoped in how to build a 3D product configurator; the API only needs to publish the outputs with correct keys.
Server-side rules, pricing, and quote persistence
Client-side rules improve UX; they do not authorize a sale. Re-validate on every quote and again before order accept, then persist a frozen configuration revision that downstream systems can replay.
A sound quote model:
- Interactive price — cheap, may be advisory, still computed server-side.
- Frozen quote — locks configuration revision, price book version, and a
validUntilwindow. - Order accept — load the frozen document, run rules against current catalogs, and fail closed if options became illegal.
Never compute the commercial total only in the browser. Editable client prices and stale option trees are how bad BOMs reach production. Headless B2B practice puts a configuration service between the UI and the commerce API so the cart only receives validated documents (architecture pattern summarized by Balázs Csorba, 2026).
Eventing: webhooks to ERP, CRM, and Shopify
Use synchronous HTTP for the interactive configure loop. Use signed webhooks for systems that should not sit on the hot path — ERP item creation, CRM opportunity updates, analytics, and cart adapters.
Minimum event set worth supporting:
| Event | When it fires | Typical consumer |
|---|---|---|
configuration.updated | Option patch succeeds | Analytics, live agents |
configuration.saved | Buyer or rep persists a shareable ID | CRM, email share links |
quote.created | Frozen quote issued | ERP, CPQ, sales ops |
order.submitted | Commerce accepts the configuration | MES, fulfillment, finance |
Operational requirements that separate demos from platforms:
- HMAC signatures (or mTLS) and rotating secrets.
- Idempotency keys so retries do not double-create ERP items.
- At-least-once delivery with consumer-side deduplication.
- Payload includes
configurationId,revision, tenant, and a compact option map — not only a render URL.
For Shopify or other commerce hosts, keep the same split. Your BFF receives quote.created or a client "add to cart" intent. It then posts line items plus configuration metadata to the cart API you already own.
Vividworks' public embed model is explicit about that split. getPricesCallback and addToBasketCallback push sales and BOM data to the host. A dedicated REST API remains on the roadmap (Vividworks integration; API roadmap note).
How platforms expose APIs (editorial survey)
Vendors expose four recurring API shapes — composable REST, embed Web API, data API + apiKey, and host callbacks. None is universally "more headless"; they differ in where authority lives and how much UI they assume.
| Shape | Example | What you integrate | Watch-out |
|---|---|---|---|
| Composable client + REST | Threekit | Config without player; REST assets, saved configs, webhooks | Public vs private token discipline |
| Embed Web API | Mimeeq | mimeeqApp / mimeeqAuth on the host page | Logic can stay coupled to the embed runtime |
| Data API + apiKey | 3D Cloud | MxtKongfigurator, IConfiguratorDataAPI | Strong for storefront embed; map carefully to ERP IDs |
| Host callbacks | Vividworks | Price and basket Promises from the host | Dedicated REST still roadmap — plan for callbacks |
| Custom headless | Your services | Config + pricing + CDN + webhooks behind BFF | Required when CAD, multi-tenant CPQ, or ERP owns price |
Threekit's composable configurator is a useful design reference. The front end can read attributes and call setConfiguration without loading a player, then pair a separate viewer when visuals are needed (Threekit composable configurator). Mimeeq documents programmatic control of configuration, pricing, camera, and exports through the embed Web API (Mimeeq Web API). 3D Cloud's integrations guide centers on apiKey plus configurationId. It also exposes a read-oriented data API for host apps and automation systems (3D Cloud integrations).
Choose custom or hybrid when Gate 0 says native CAD. Choose them also when tenants bring their own price books, or when ERP — not the player — is the authority on legality and cost. That decision framework lives in the build vs buy scoping guide.
For pattern recognition before you write OpenAPI specs, the production examples gallery shows how industrial CPQ and ERP build-sheet flows differ from furniture material swaps. The API surface is the same five groups; the rule depth and event consumers change by vertical.
Integration checklist before you commit
Lock ownership and contracts before you debate renderers or vendor demos. The checklist below is the MOFU gate for platform teams.
- Who owns rules? Player, config service, or ERP — pick one authority.
- Who owns price? Same question; browser is never the answer for finals.
- Is there a durable configuration ID + revision? Cart and CRM must store it.
- Can you re-validate a frozen quote against current catalogs? Fail closed.
- Are glTF bindings versioned and CDN-cached? Content hashes, not mutable filenames.
- Public vs private credentials? Domain allowlists; no private tokens in JS bundles.
- Tenant isolation on every row? Including asset URLs and price books.
- Webhook consumers named? ERP, CRM, analytics — with signatures and idempotency.
- Embed boundary chosen? iframe vs web component vs first-party app.
- Observability? Trace option change through validate, price, persist, and event delivery.
If you are building the Three.js client yourself, continue with the SaaS embed architecture guide. If you need a partner for WebGL, CPQ wiring, and CAD-heavy assets, see WebGL 3D product configurator development services.
Frequently Asked Questions
What should a 3D product configurator API expose?
At minimum: catalog context, create/patch configuration state, server-side validation, pricing or quote creation, versioned asset bindings, and lifecycle webhooks. Player methods that only mutate a loaded scene are not enough for ERP or multi-channel commerce.
Should pricing live in the configurator or in commerce/ERP?
Final commercial price belongs in commerce, CPQ, or ERP. The configurator API may call that system and cache a snapshot on a quote, but the browser must not be the authority. Re-price and re-validate when a quote freezes and again when an order is accepted.
How do you integrate a headless configurator with Shopify or ERP?
Persist a configuration revision, then either post line items from your BFF into the cart API or emit quote.created / order.submitted webhooks your middleware consumes. Include configuration ID, revision, and option map so support and manufacturing can replay the exact build.
Do I need a vendor API or a custom headless service?
Buy or embed when artist-ready catalogs and host callbacks fit your channels. Design custom headless when geometry is CAD-sourced, tenants are isolated SaaS customers, or ERP owns legality and price. Many teams land hybrid: vendor or custom visuals over your pricing service.
Conclusion
A 3D product configurator API is the contract that makes interactive 3D safe for platform stacks. Own configuration state and rules on the server. Return price and glTF bindings from that same truth. Persist revisions buyers and systems can replay. Fan out with signed webhooks — do not pretend an embed SDK is your integration layer.
Design the five capability groups and the config to price to order flow before you pick a player. Then choose Threekit, Mimeeq, 3D Cloud, Vividworks-style callbacks, or custom services based on where authority must live — not on demo polish.
Next step for the browser client: build the Three.js SaaS embed. For cost bands before you staff the API work, see how much a configurator costs to build. If you want the stack built with you, see WebGL configurator development services.

