Your Fine-Tuned Models — Consumption & Pricing

When you fine-tune a model with ToothFairyAI, it stops being "an AI model" and becomes your model — trained on your data, private to your workspace, and selectable in the model picker by the name you gave the training job, exactly like any other model.

This page explains, in plain language, what it costs to use your model and what to expect in terms of speed.

How it is priced: one price, based only on size

Using your fine-tuned model is billed per token, from your UoI credit balance — the same credits you use for everything else (1 UoI = $0.01 USD).

The price is one flat rate per million tokens, and it depends on one thing only: the size of the model you chose when you trained it. There is no separate rate for questions versus answers — the model reading your conversation and writing its reply are billed at the same rate. No maths required: one number, one size.

Model size	Typical examples you may have trained	Flat rate per 1M tokens
Small	Llama 3.2 1B / 3B, Qwen 3 4B	60 UoI
Medium	Llama 3.1 8B, Qwen 3 8B, Mistral 7B	80 UoI
Large	Qwen 14B, Gemma 3 12B	200 UoI
Extra large	Qwen 32B, Gemma 3 27B	1,600 UoI
Largest	Llama 70B, GPT-OSS 120B	3,000 UoI

What's a token?

A token is just a small piece of text — a word is roughly one to two tokens. Everything the model reads (your question, the conversation history, any documents in context) and everything it writes counts as tokens. For comparison, this sentence is about 25 tokens.

Keeping a model warm (optional)

The prices above apply to normal on-demand serving. If you want a model warm and instantly responsive inside set hours (or around the clock), warm hours bill at a flat hourly rate by model size, in 1-hour units (minimum 1 unit, rounded up), with token usage still billing on top:

Model size	Warm hour rate
Small	220 UoI
Medium	360 UoI
Large	520 UoI
Extra large / Largest	2,440 UoI

How the meter works:

Warm time accrues only while the lane is deliberately held for you — manual power-on, a schedule window, or always-on mode. The automatic on-demand wake-up is never billed.
Billing runs once per day at 03:00 UTC against your UoI balance; a 10-minute hold is billed as one full hour.
The clock starts when the hold is requested, so the wake-up minutes are inside your first hour. Releasing the hold stops the meter immediately, but already-accrued partial time still rounds up at the daily run.
Not-yet-billed accrued time is visible as warm_seconds_accrued on the serving status call, and in the platform's fine-tuned model panel.

Worked examples:

A Medium model scheduled weekdays 07:00–17:00 runs 10 warm hours/day → 3,600 UoI/day.
Always-on on a Medium model ≈ 259,000 UoI/month — that tier makes most sense for enterprise workloads.

Schedules, cron rules and on/off control from your own scripts are covered in Serving & Availability.

What you should expect in practice

Your model sleeps when nobody uses it — and sleeping is free. There is no standing charge for having a fine-tuned model. You are never billed just because the model exists. You only pay for the tokens it actually processes when someone talks to it.

The first message after a rest takes a few minutes — and the wake-up is free. To keep your costs at zero when idle, your model is switched off after about 15 minutes of inactivity. The next message automatically switches it back on. That wake-up typically takes 8–12 minutes end-to-end on a small lane (~9 minutes measured: instance provisioning, container start, base-model download and load, health checks) — think of a car warming up on a cold morning. You don't need to click anything; it happens on its own, and you are not charged for the waiting time — billing starts only when your model actually answers. The first reply after the wake-up also loads your model's adapter (~30 seconds, one-off); after that, replies come in ~1–2 seconds. Larger bases (70B-class) take longer to wake — expect roughly 10–20 minutes.

While it's awake, it behaves like a normal model. Once awake, your model stays warm and answers at the normal speed you'd expect from a model of that size, message after message. If people are chatting with it regularly through the day, it simply stays awake.

Bigger models: smarter, slower, pricier. The trade-off you chose at training time carries through to usage. A small model is the quickest and cheapest per token — great for high-volume, simple tasks. Larger models give more capable answers but take longer to reply and cost more per token. If you find a small model handles your task well, it will also be your cheapest option to run.

A worked example

Your team fine-tunes a Llama 3.1 8B model (Medium, 80 UoI per 1M tokens) and uses it as the model for a customer-support agent.

Situation	Tokens involved	Cost
One support chat: the model reads the question + conversation (~2,000 tokens) and writes a ~500-token answer	2,500	0.2 UoI
A busy morning: 50 such chats	~125,000	10 UoI
The model sits unused all weekend	0	0 UoI

A whole day of fairly heavy use of a Medium model typically costs well under 100 UoI. Large and Largest models cost proportionally more per token — the same table above applies, just at their rate.

Using your model

Once training finishes, your model is ready immediately — there is no deployment step. There are two ways to use it:

In the platform. Your model appears in the model picker under the name you gave the training job (e.g. Llama 3.1 8B Instruct abcd1234). Select it for any chat or agent, exactly like a standard model.

Through the API. Call it by name on the OpenAI-compatible chat endpoint:

curl -X POST https://ais.toothfairyai.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "model": "ToothFairyAI/Meta-Llama-3.1-8B-abcd1234",
    "messages": [{"role": "user", "content": "What did I teach you about our refund policy?"}],
    "stream": true
  }'

To find your model's exact API name, look in the platform model picker or call GET /models_list?workspaceid=<your workspace id> — your fine-tuned models are listed there with their price. Any app that speaks the OpenAI API works too: point it at https://ais.toothfairyai.com/v1 with your workspace API key as the API key.

Things to know:

If the model has been idle, the first request waits ~8–12 minutes while it wakes up (plus ~30 s one-off adapter load on the first reply) — that wait is free (see What you should expect in practice).
Your model's abilities follow the base you trained: a vision base (e.g. Qwen-VL) accepts images, a reasoning base (e.g. DeepSeek-R1, GPT-OSS) thinks before answering, and tool calling depends on the base model. The model list shows exactly what your model supports.
Tool/function calling, streaming and non-streaming replies all work as usual.
Every reply is billed at the flat rate from the table above and appears in your dashboard under the model's name.

How this compares to training costs

Training a model (the fine-tuning job itself) and running it are billed separately:

Training is billed for the compute the job uses — see the Fine-tuning page for how that is metered.
Running the finished model is what this page covers: a flat rate per million tokens, by model size.

Once a model is trained, keeping it around costs nothing until someone uses it.

Observability

Every conversation with your fine-tuned model appears in your workspace dashboard usage view, itemised by model name — so you can see exactly how much each of your models is consuming, alongside your other AI usage.

The pricing API

The numbers on this page are also available programmatically through the Fine-Tuning API — handy for quoting, budgeting scripts or dashboards:

# The full tier table (what this page shows)
curl "https://api.toothfairyai.com/finetuning/pricing" \
  -H "x-api-key: YOUR_API_KEY"

# Pricing resolved for a trainable base model
curl "https://api.toothfairyai.com/finetuning/pricing?base_model=unsloth/Llama-3.2-1B-Instruct-bnb-4bit" \
  -H "x-api-key: YOUR_API_KEY"

# Pricing resolved for one of your completed fine-tuned models
curl "https://api.toothfairyai.com/finetuning/pricing?trainingLogId=YOUR_TRAINING_LOG_ID" \
  -H "x-api-key: YOUR_API_KEY"

The third form also returns the model's model_id and its size tier, so you can label usage reports without an extra lookup. Warm-lane hourly rates (warm_hourly_usd) are included in every response. All amounts in the API are expressed in USD — multiply by 100 for UoI (1 UoI = $0.01).

Summary

One flat price per million tokens, based only on the size of your model — reading and writing billed at the same rate.
Small (60) → Largest (3,000) UoI per 1M tokens; see the table above.
Warm hours (optional): 220–2,440 UoI per hour by size, billed daily in 1-hour units — the automatic wake-up is always free.
No standing charges — a model that nobody uses costs nothing.
First message after idle waits ~8–12 minutes for the free automatic wake-up (plus ~30 s one-off adapter load on the first reply); afterwards replies arrive in ~1–2 seconds.
Bigger models are more capable but slower and pricier — the choice you made at training time.
All charges are drawn from your UoI credit balance (1 UoI = $0.01 USD) and visible per model in the workspace dashboard.

How it is priced: one price, based only on size​

Keeping a model warm (optional)​

What you should expect in practice​

A worked example​

Using your model​

How this compares to training costs​

Observability​

The pricing API​

Summary​