GPU Token Platform for Data Centers

Sell the GPUs in your data center by the token, not by the server

Turn data-center GPUs into a metered AI service: an OpenAI-compatible API, per-token metering, prepaid wallets, and Thai billing, built on top of your GPU cluster.

Abstract composition of a GPU chip, token stream, and ledger in HarmonyX blue and gold

Organisations that own or are building GPU capacity and need to sell or allocate it as an AI service.

01

Data Center & Colocation Operators

GPU capacity already racked, with no product layer to sell inference to developers by usage.

02

Telco & Cloud Providers

A local AI inference offer that has to bill through existing customer accounts and invoicing.

03

Sovereign & Public-Sector AI

Models that must run on in-country hardware, with usage attributed and auditable per agency or project.

04

Enterprises with Private GPU Clusters

Internal GPU capacity shared between business units that needs chargeback by team and project.

05

Universities & Research Institutes

Shared clusters allocated to labs and students by quota, with spend limits per group.

06

AI Startups & Model Providers

Serving their own or open-weight models to customers with metered, prepaid billing from day one.

Four phases, layered the way the platform is: access first, then the token core, then the commercial layer.

  1. 01

    Scope

    Agree the boundary: which models, which customer segments, and who operates the inference layer, your team (Option A) or HarmonyX (Option B).

  2. 02

    Access

    Stand up the OpenAI-compatible gateway with TLS and streaming, API keys per organisation and project, and RPM/TPM limits and spend caps per key.

  3. 03

    Token core

    Route each model to the right cluster with load balancing and fallback, meter input and output tokens as immutable usage events, and settle every request against a prepaid wallet in a double-entry ledger.

  4. 04

    Commercial

    Price per 1M tokens with tiers and enterprise rates, bill by PromptPay, card, or transfer with e-Tax Invoice, and launch the developer portal and admin console with daily reconciliation.

The layers between your users and your GPUs, running on the cluster you already operate.

Access Layer

  • OpenAI-compatible API
  • TLS & SSE streaming
  • API keys & orgs
  • RPM / TPM limits
  • Spend caps

Token Core

  • Model router
  • Load balancing & fallback
  • Token metering
  • Reserve & settle wallet
  • Double-entry ledger

Inference Layer

  • vLLM
  • SGLang
  • Model registry
  • Usage reporting
  • Kubernetes

Commercial & Ops

  • Pricing per 1M tokens
  • PromptPay / cards / transfer
  • e-Tax Invoice
  • Observability & audit log
  • Daily reconciliation

A data center with GPUs has compute. What it usually doesn’t have is a product: a way for a developer to sign up, get an API key, call a model, and pay for exactly the tokens they used. Without that layer, GPU capacity gets sold the old way, by the server and by the month, to the few customers big enough to run their own inference stack. We build every layer between your users and your GPUs so the capacity can be sold by the token.

What sits between your users and your GPUs?

Three layers, built on top of the cluster you already run.

  • Access layer: an OpenAI-compatible API gateway with TLS and streaming (SSE), API keys issued and revoked per organisation and project, and RPM/TPM rate limits, spend caps, and alerts per key
  • Token core: a model router that picks the right cluster for each model with load balancing and fallback, metering of input and output tokens, and a wallet and ledger that every request settles against
  • Commercial layer: a pricing engine per 1M tokens with tiers and enterprise rates, billing by PromptPay, card, or transfer with invoices and e-Tax Invoice, and a developer portal plus an admin console with reporting

Underneath all three sit observability, an audit log, notifications, and a daily reconciliation job that checks usage, ledger, and payments agree.

Why metering and the ledger are the core

Everything a customer is billed for traces back to two components. Metering records every request’s input and output tokens as a usage event that can’t be edited after the fact. The wallet reserves an estimated cost before a request runs and settles the actual cost when it finishes, so a prepaid customer can’t run past their balance. Both write to a double-entry ledger, which means every baht can be traced from the invoice back to the requests that produced it. Get these two right and pricing, billing, and reporting are straightforward. Get them wrong and no dashboard will fix the disputes.

If you can’t trace an invoice line back to the requests that produced it, you aren’t selling tokens. You’re selling estimates.

Who runs the inference layer?

The inference layer serves the models with vLLM or SGLang, keeps a registry of models and versions, and reports token counts back to metering through an internal API. We agree who operates it at the start of the engagement.

  • Option A: your team operates inference on your cluster, and we integrate the platform with it through the internal API
  • Option B: HarmonyX deploys and operates the inference layer on your GPU cluster as part of the engagement

What stays with you

The data center itself: GPU servers procured by you or your vendor, the Kubernetes cluster with its compute, storage, and network, and the facility’s power, cooling, and physical security. The platform runs on top of that infrastructure. It doesn’t replace it.

If you have GPU capacity and no way to sell it by usage, start with an architecture workshop. We map your cluster, the models you want to serve, and who your customers are, then agree the scope, including who runs inference.

Properties designed in from the first release, not added later.

Every token

recorded as an immutable usage event, so any invoice line traces back to requests

No overspend

requests reserve against the wallet before they run and settle when they finish

Drop-in API

OpenAI-compatible, so existing SDKs and tools work by changing the base URL

Daily close

usage, ledger, and payments reconciled every day, with mismatches flagged

Frequently Asked Questions

What does HarmonyX build in a GPU token platform?

Every layer between your users and your GPUs: an OpenAI-compatible API gateway, API keys and rate limits, a model router, per-token metering, a prepaid wallet with a double-entry ledger, a pricing engine per 1M tokens, PromptPay, card, and transfer billing with e-Tax Invoice, and a developer portal and admin console. Observability, audit logging, and daily reconciliation run across all of it.

Do we have to hand over our GPU cluster to HarmonyX?

No. Your GPU servers, Kubernetes cluster, and facility stay yours. For the inference layer that serves models with vLLM or SGLang, you choose: your team operates it and we integrate through an internal API (Option A), or HarmonyX deploys and operates it on your cluster (Option B).

How do you make sure customers are billed correctly?

Every request’s input and output tokens are recorded as an immutable usage event. The wallet reserves an estimated cost before the request runs and settles the actual cost after, and both write to a double-entry ledger. A daily reconciliation job checks that usage, ledger, and payments agree, so any invoice line can be traced back to the requests that produced it.

Have GPU capacity and no way to sell it by usage?

Start with an architecture workshop. We map your cluster, the models you want to serve, and who your customers are, then agree the scope, including whether your team or ours runs the inference layer.

Start a conversation