Pricing

You pay OpenAI's list price for every token, second of audio and embedding. There is no markup and no subscription. Discounts come as bonus credit when you add $50 or more in a single top-up.

Costs are taken from your prepaid credit balance. See Credits & billing for how credit is held, charged and topped up.

Check what a request cost

Every response reports its usage and the service tier that served it. Glexir bills exactly that usage at that tier.

import Glexir from "@glexir/sdk";

const glexir = new Glexir({ apiKey: process.env.GLEXIR_API_KEY });

const response = await glexir.responses.create({
  model: "gpt-5.4-mini",
  input: "Name three prime numbers.",
  service_tier: "flex",
  max_output_tokens: 200,
});

// The tier that served the request. This is the tier you are billed at.
console.log(response.service_tier);

const usage = response.usage;
console.log(usage?.input_tokens, usage?.input_tokens_details.cached_tokens, usage?.output_tokens);

Model prices

The prices above are the standard tier for requests up to the long-context threshold. The sections below cover the other tiers, long context and caching. The full price book lists every rate.

Volume discounts

A single top-up of $50 or more earns bonus credit on top of what you pay. Usage is still billed at list price; the bonus is extra credit to spend. Paying P at discount d gives you P / (1 - d) of usage.

• The discount is set by the size of one top-up, before tax. Two $500 top-ups do not add up to the $1,000 tier.
• Auto recharge top-ups earn the bonus too, by the same rule.
• Bonus credit is spent before purchased credit, cannot be refunded, and expires with the top-up that earned it.
• Your trust tier caps the size of a single top-up, so the larger bonus tiers need a higher trust tier. A tier above every trust tier's cap is only available by arrangement with Glexir. See Top-up limits.

Details are in Volume bonus credit.

Service tiers

Set service_tier on a Responses or Chat Completions request to choose how OpenAI processes it. Each tier has its own price, as a multiple of standard:

• Standard is the default. auto, default and scale all bill as standard.
• Batch applies to every request in a batch. You don't set it per request.
• Flex is cheaper and slower. It can fail with 429 when OpenAI has no capacity. A failed request is not charged.
• Fast is also accepted as priority. Both bill as fast.
• Ultrafast exists only for the models listed.

Your trust tier decides which service tiers you can request. Tier 0 and 1 accounts can use standard, flex and batch; fast needs tier 2 and ultrafast needs tier 3. Asking for a tier you can't use returns 403 with code tier_not_allowed and param: "service_tier". See Trust tiers.

The tier OpenAI reports is the tier you pay

Glexir bills the service_tier in the response, not the one you asked for. If you request auto and OpenAI serves the request at standard, you pay standard. If OpenAI reports a tier the model has no price for, the request is billed at standard.

Your hold (the credit reserved before the request runs) is sized at the tier you asked for. auto is sized at standard.

Long context

When a request has more than 272,000 input tokens, the whole request is billed at long-context rates, not just the tokens past the threshold. The multipliers apply on top of the service tier:

The threshold is checked against the request's total input_tokens, cached tokens included. A long-context batch request costs the batch rate times these multipliers.

Prompt caching

OpenAI caches repeated prompt prefixes. Cached input tokens cost much less than uncached input. Newer models also charge for writing to the cache: a 30-minute write and a 12-hour write each have their own rate. On older models a cache write costs the same as uncached input.

Glexir splits a request's input_tokens into classes and bills each at its rate:

Cache writes not reported as 12-hour writes are billed at the 30-minute rate.

Reasoning tokens are part of output_tokens. They are billed once, as output.

Embeddings

Embeddings are billed per input token, from usage.prompt_tokens in the response. Embedding requests in a batch cost half.

import Glexir from "@glexir/sdk";

const glexir = new Glexir();

const result = await glexir.embeddings.create({
  model: "text-embedding-3-small",
  input: ["first document", "second document"],
});

console.log(result.usage.prompt_tokens); // tokens billed

Transcription

Transcription is billed per second of audio, at the per-minute price in the table above divided by 60.

• The billed duration is usage.seconds from OpenAI, rounded up to a whole second, with a minimum of one second.
• If OpenAI returns no usage, Glexir measures the audio file, or estimates its length from its size, and bills that.

import { readFile } from "node:fs/promises";
import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir();

const transcript = await glexir.audio.transcriptions.create({
  model: "gpt-transcribe",
  file: await toFile(await readFile("meeting.mp3"), "meeting.mp3"),
});

console.log(transcript.text);

Dated model snapshots

OpenAI sometimes reports a dated snapshot, such as gpt-5.4-mini-2026-03-17, for a request you made with the alias gpt-5.4-mini. Glexir bills the snapshot at the alias's rates. Send the alias model IDs listed above in your requests.

Models not in the price book are rejected before they reach OpenAI, with 403 and code model_not_priced.

How costs are calculated

All money in Glexir is stored in nano-USD: billionths of a dollar. Rates are stored per 1 million units. For each token class, the cost is:

cost in nano-USD = ceil(tokens × rate in nano-USD per 1M / 1,000,000)

The request's cost is the sum of its classes. Rounding is always up, by less than one nano-USD per class. This keeps very cheap rates, such as cached input on small models, from rounding to zero.

For example, a standard request with 12,345 input tokens, 8,192 of them cached, and 678 output tokens:

Balances in the dashboard are shown to the cent. The usage export keeps full precision.

Full price book

Every rate for every text model, at every service tier and context band, per 1M tokens. A dash means the model has no price at that tier.

Files and model listing are free.