LIX & Economy
LIX is HELIX's hard currency. The wallet, in-world purchases, the marketplace, and the rules that keep value stable — all server-authoritative.
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.
LIX pays for premium items, collectibles, platform services, and in-world purchases. Creators earn LIX and can cash it out; stipend LIX is spend-only.
The economy is server-authoritative — always
Every LIX-affecting action is settled on the server. Clients request purchases; they never grant currency or items. All in-world purchase charges deduct LIX server-side. Treat any client-reported balance or grant as untrusted.
The wallet
Helix.wallet reads balances and initiates purchases.
Prop
Type
const { lix, coins } = await Helix.wallet.getBalance();In-world purchases (IWP)
To sell something for LIX, the client requests and the server authorizes and settles. The SDK gives you an idempotency key so retries can't double-charge.
// client: request a purchase
const result = await Helix.marketplace.purchaseItem('premium_sword_001');
if (result.status === 'completed') {
// item is now in the player's inventory, charged server-side
}local result = Helix.marketplace.purchaseItem("premium_sword_001")
if result.status == "completed" then
-- granted + charged server-side
endFor full control (consumables, custom pricing) the server validates and calls the authoritative grant/charge APIs — see the Inventory execution tiers and the Sell an item for LIX guide.
What worlds can build
Two ways to sell: a catalog item (an existing universal item listed on the Marketplace —
purchaseItem(itemId)) or a world product (a purchasable you register on your world —
purchaseProduct(productId)). Both settle the same way: the client requests, the server charges LIX
and grants atomically. A price of 0 makes it a free Claim (still tracked and idempotent).
| You want to… | How | Calls |
|---|---|---|
| Run a brand flagship store — products on pedestals, walk up and Buy | List your items, open the purchase popup on interact | marketplace.getListings → purchaseItem |
| Hand out free souvenirs at that store | List the item at price 0; the popup shows Claim | purchaseItem (free) |
| Sell a world-defined product (a "Golden Key" that unlocks a door) | Register a product, prompt it, gate on ownership | purchaseProduct → inventory.hasItem |
| Grant VIP / backstage access — even across other creators' worlds | Check if the player owns a "VIP Pass" item | inventory.hasItem(vipPassId) |
| Gate seasonal content behind a season pass | Check ownership of the pass item | inventory.hasItem(seasonPassId) |
| Let players show off / equip a cosmetic they own | Read inventory, equip the item | inventory.getMyItems → equipItem |
| Unlock a purchase only for owners of another item | Check ownership, then prompt | hasItem(x) → purchaseItem(y) |
| Drop a limited collectible (a giveaway as first-come claim) | List a supply-capped collectible, free or priced | purchaseItem |
| Show a LIX-aware UI (disable Buy when short) | Read the balance, subscribe to changes | wallet.getBalance + onBalanceChanged |
Universal items are physical things
Items players own are placeable, tradeable, equippable things — home décor, wearables,
collectibles. Pure gameplay effects (an extra life, a speed boost) are world product purchases your
own gameplay code fulfils on a completed result — they are not universal items. Trading happens on
the Marketplace, not in the world SDK.
World products
A world product is a purchasable a world registers — the Roblox "developer product" analog. The
price lives on the product server-side; clients reference a productId, never a price. Register a
product before prompting it (see Sell an item for LIX).
Prop
Type
type
Marketplace item vs world product — when to use which
Both settle through the same charge→grant core and return the same PurchaseResult. A
marketplace item (purchaseItem(itemId)) sells an existing
universal item at its listing price and pays the
item's creator. A world product (purchaseProduct(productId)) is registered by your world,
pays the world's creator, and is the only option for world-defined pricing/bundles or a pure
gameplay consumable.
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.
| Method · path | Body | Returns |
|---|---|---|
POST /api/v1/iwp/products | { worldId, title, description?, priceLix, type, itemId?, maxPerUser? } | the created product |
PATCH /api/v1/iwp/products/:id | { title?, description?, priceLix?, maxPerUser?, active? } | the updated product |
POST /api/v1/iwp/products/:id/active | { active: boolean } | the product |
GET /api/v1/iwp/products/:id | — | the product |
curl -X POST "$API/api/v1/iwp/products" \
-H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
-d '{"worldId":"…","title":"Golden Key","priceLix":250,"type":"non_consumable","itemId":"…","maxPerUser":1}'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:
| Method · path | Purpose |
|---|---|
GET /api/v1/iwp/context?ref=&worldId= | product/listing + live balance + eligibility (for the popup) |
POST /api/v1/iwp/purchase | { ref, worldId?, idempotencyKey } → a PurchaseResult |
GET /api/v1/iwp/purchase/:idempotencyKey | status of a purchase (resume after a dropped connection) |
ref is a productId or item:<universalItemId>. The server always resolves price + payee itself —
a client-supplied price is never trusted.
The marketplace
Helix.marketplace lists items, collectibles, and listings, and initiates purchases. Rare
collectibles trade peer-to-peer for LIX (redistribution, never minted on demand).
In-world purchases vs the Marketplace — two different things
These are distinct concepts that today share the Helix.marketplace namespace:
- In-world purchases (
purchaseItem/purchaseProduct) are a world selling to a player — a store/checkout. The analog is iOS StoreKit or Android Play Billing (and Roblox developer products): billing, not a storefront you browse. A world product belongs to its world, not the global exchange. - The Marketplace (
getListings) is the platform-wide, peer-to-peer exchange for universal items and collectibles — players trading with players, like the Roblox avatar catalog or an app store's browse surface.
iOS and Android keep these separate (StoreKit/Billing vs the store you browse); HELIX may likewise
split them into distinct namespaces (e.g. Helix.iwp and Helix.marketplace) later. The method
contracts above won't change.
Prop
Type
Fees & payouts (platform policy)
- Platform commission ≈ 25% (creators keep ~75%), down to ~10% for top tiers.
- Resale/trade fee ≈ 10%, down to ~3% by tier.
- Creator earnings are cashable (with KYC); stipend LIX is not.
These are platform-enforced — you don't implement them.
Don't expose the provider
Payment processors and ledger internals are never part of the public SDK. You call Helix.wallet
and Helix.marketplace; HELIX handles settlement.
Reference
- Web SDK →
Helix.wallet/Helix.marketplace - Guide → Sell an item for LIX