LIX & Economy

HELIX has a real, platform-wide economy. Two currencies:

• Coins — soft currency, earned and spent across worlds.
• LIX — hard currency, bought with real money. 100 LIX ≈ $1 (bundles can discount).

LIX pays for premium items, collectibles, platform services, and in-world purchases. Creator earnings land in the creator's withdrawable LIX balance; a cash-out flow is not part of the public API today.

LIX Credits

LIX Credits are a restricted kind of LIX, for example the one-time open-alpha starter grant. They pay for platform services (Dreamer, publish and mint fees, hosting, storage) but never for another creator's item or product, and they can't be transferred or cashed out. A purchase that would pay a creator only counts your other LIX, so a player holding only Credits gets InsufficientFunds.

The wallet

Helix.wallet reads balances. Purchases go through Helix.marketplace (below).

const { lix, coins } = await Helix.wallet.getBalance();

In-world purchases (IWP)

To sell something, the client requests and the server authorizes and settles. The SDK persists an idempotency key per attempt so a retry can't double-charge, and the shell owns the Buy / Claim confirmation.

// client: request a purchase of a product your world registered with key "golden-key"
const result = await Helix.marketplace.purchaseProduct('golden-key');
if (result.completed) {
  // Granted, Claimed or AlreadyOwned: charged and fulfilled server-side
}

result.status is one of Pending, Granted, Claimed, AlreadyOwned, InsufficientFunds, MaxPerUserReached, ProductInactive, ProductNotFound, NotInWorld, Unauthorized, RateLimited, Cancelled, Failed, Timeout, NotFound or PriceChanged. completed is the success convenience. After a reload or a dropped response, recover with Helix.marketplace.getPurchase(idempotencyKey, ref).

World code never grants or charges anything itself. A consumable is a world product with a currency grant that the world later spends with the server-atomic Helix.purchases.consume. See the Inventory execution tiers and the Sell an item for LIX guide.

What a world can sell

A purchase names exactly one server-owned route. An item definition on its own is not a purchase reference: the server rejects item:<id> refs and the SDK rejects raw item UUIDs.

A distribution is how a creator sells a universal item: a primary offer with its own price (LIX or Coins), per-player cap, claim cap and optional start/end window. A distribution or product priced 0 is a free Claim (still tracked and idempotent). quantity can be 1 to 100, except listings, which are always 1.

World products

A world product is a purchasable a world registers — the Roblox "developer product" analog — for world-local effects: passes, named currency balances and consumables. It can't hand over a universal item: the server rejects a product with an itemId or an item grant and points you at a distribution instead. The price lives on the product server-side; world code names the product by its key (purchaseProduct('golden-key') sends pkey:golden-key), never by a price or a UUID. Register a product before prompting it (see Sell an item for LIX).

Fulfilment is recorded as the player's entitlements in this world, which Helix.purchases reads and spends:

Limits per world: 512 products, 16 currency codes and 16 pass keys.

Managing products over HTTP

Registering and managing products is a creator / server action — there's no world-runtime SDK call for it (worlds only prompt purchases). Call these with the creator's session; only a world's owner may manage its products.

curl -X POST "$API/api/v1/iwp/products" \
  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -d '{"worldId":"…","key":"golden-key","title":"Golden Key","priceLix":250,"grants":[{"kind":"pass","passKey":"golden-key"}]}'

The purchase surface is shell-mediated (worlds call the SDK; the platform shell settles), but the endpoints exist for completeness — all require the player's session:

ref is pkey:<key>, dkey:<key>, distribution:<id> or listing:<id>; anything else is ProductNotFound. The server always resolves price + payee itself — a client-supplied price is never trusted. A player is limited to 20 purchase attempts a minute.

The marketplace

Helix.marketplace browses listings and initiates every in-world purchase. Rare collectibles trade peer-to-peer for LIX on the Marketplace; a world can feature a single listing with purchaseListing.

options is { quantity?, idempotencyKey? } (or a bare quantity number). Omit idempotencyKey and the SDK persists one for you. Outside the shell, purchases resolve { status: 'Unauthorized', completed: false } and reads resolve empty or null.

Fees & payouts (platform policy)

• Collectible resales carry a seller fee of 10% by default (5% on Plus, 2.5% on Gold, 0% on Diamond) plus a 5% royalty to the original creator when the seller isn't the creator. The buyer pays no surcharge. Rates are platform-owned, snapshotted on each trade, and creators can't override them.
• Publishing an item can cost a one-off, non-refundable LIX fee by kind, unless the platform has free uploads switched on. Read the live state from GET /api/v1/universal-items/publish-config rather than assuming it.
• LIX Credits can't pay a creator, and nothing in the public API cashes LIX out today.

These are platform-enforced — you don't implement them. The figures are the backend's defaults and can be changed by platform configuration.

Reference

• Web SDK → Helix.wallet / Helix.marketplace / Helix.purchases
• Guide → Sell an item for LIX