Pattern: estimate cost

Dex charges input tokens only, and output is free, so a request's cost is known before it runs: usage.input_tokens times the rate. You never estimate output. Measure a representative request once with a free test key, multiply by your volume, and compare the ways to pay.

Step 1: measure one request#

Send one typical request with a test key: it costs nothing, and the same request costs the same number of tokens on a live key.

curl -s https://api.thinqit.ai/v1/decide \
  -H "authorization: Bearer $DEX_API_KEY" \
  -H "content-type: application/json" \
  --data-binary @request.json | jq .usage

usage.input_tokens is the billed count: state_tokens (your text, billed once however many questions share it) plus question_tokens (every question's instructions, criteria and options or levels). The recipes in this cookbook measure like this:

Prices exclude VAT. A plan's rate applies to tokens inside its weekly allowance; tokens beyond it are paid at the pay-as-you-go rate.

Two things move the count: the length of the state, and the number and length of the questions. Adding a question to an existing request costs only its own question tokens. Long option descriptions on a pick with many options add up; keep them short.

Step 2: compare the ways to pay#

GET /v1/plans returns the plans with their current prices, weekly allowances and effective rates, without a key. Read them at run time instead of copying prices into your code.

import httpx

CALLS_PER_MONTH = 400_000
TOKENS_PER_CALL = 185  # usage.input_tokens of your measured request

plans = httpx.get("https://api.thinqit.ai/v1/plans", timeout=30).json()
standard = plans["standard_unit_price_micro_cents"]  # micro-cents per input token, pay as you go
tokens_month = CALLS_PER_MONTH * TOKENS_PER_CALL
tokens_week = tokens_month * 12 / 52

def eur(micro_cents: float) -> float:
    return micro_cents / 100_000_000  # 1 EUR = 100,000,000 micro-cents

print(f"{tokens_month:,} input tokens a month")
print(f"pay as you go: EUR {eur(tokens_month * standard):,.2f} a month")
for p in plans["data"]:
    overage_week = max(0, tokens_week - p["week_allowance_tokens"])
    monthly = p["price_cents"] / 100 + eur(overage_week * 52 / 12 * standard)
    seats = "" if p["available"] else " (no founding-round seat left)"
    print(f"{p['name']}: EUR {monthly:,.2f} a month{seats}")

const CALLS_PER_MONTH = 400_000;
const TOKENS_PER_CALL = 185; // usage.input_tokens of your measured request

type Plan = { name: string; price_cents: number; week_allowance_tokens: number; available: boolean };
const plans = (await (await fetch("https://api.thinqit.ai/v1/plans")).json()) as {
  standard_unit_price_micro_cents: number;
  data: Plan[];
};
const standard = plans.standard_unit_price_micro_cents; // micro-cents per input token, pay as you go
const tokensMonth = CALLS_PER_MONTH * TOKENS_PER_CALL;
const tokensWeek = (tokensMonth * 12) / 52;
const eur = (microCents: number) => microCents / 100_000_000; // 1 EUR = 100,000,000 micro-cents
const fmt = (x: number) => x.toLocaleString("en-GB", { minimumFractionDigits: 2, maximumFractionDigits: 2 });

console.log(`${tokensMonth.toLocaleString("en-GB")} input tokens a month`);
console.log(`pay as you go: EUR ${fmt(eur(tokensMonth * standard))} a month`);
for (const p of plans.data) {
  const overageWeek = Math.max(0, tokensWeek - p.week_allowance_tokens);
  const monthly = p.price_cents / 100 + eur(((overageWeek * 52) / 12) * standard);
  console.log(`${p.name}: EUR ${fmt(monthly)} a month${p.available ? "" : " (no founding-round seat left)"}`);
}

Save the TypeScript as cost.mts and run npx tsx cost.mts. Both print the monthly input tokens, the pay-as-you-go cost and each plan's cost with the overage, from the prices the API returns today. Prices exclude VAT.

How the plans work#

• The allowance is a number of input tokens per week that resets every 7 days from the day you subscribed. Unused tokens do not roll over, so spread steady traffic over the week.
• Calls beyond the allowance are paid from the prepaid balance at the pay-as-you-go rate. With no allowance and no balance left, a live call gets 402 insufficient_balance and is not charged; its hints say what to do. See Tokens and billing.
• A reset refills the current week's allowance at once, for a quarter of the monthly price.

Keep an eye on it#

• GET /v1/balance (scope balance:read) shows the plan, week_used_tokens of week_allowance_tokens, week_resets_at and the prepaid balance.
• GET /v1/usage (scope usage:read) gives day or hour buckets with input_tokens, allowance_tokens, paid_tokens and charge_micro_cents. end is the first day not included, so end = tomorrow includes today.
• The console shows the same numbers, and emails the account owner when the balance runs low or a week's allowance is used up.