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 | $0.60 — 60 UoI |
| Medium | Llama 3.1 8B, Qwen 3 8B, Mistral 7B | $0.80 — 80 UoI |
| Large | Qwen 14B, Gemma 3 12B | $2.00 — 200 UoI |
| Extra large | Qwen 32B, Gemma 3 27B | $16.00 — 1,600 UoI |
| Largest | Llama 70B, GPT-OSS 120B | $30.00 — 3,000 UoI |
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 in 1-hour units (minimum 1) at a flat hourly rate by model size — Small $2.20, Medium $3.60, Large $5.20, XL/Largest $24.40 per hour — with token usage still billing on top. See Serving & Availability for schedules, on/off control from your own scripts, and worked examples.
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 5–10 minutes — 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.
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 ≈ $0.002 |
| A busy morning: 50 such chats | ~125,000 | 10 UoI ≈ $0.10 |
| The model sits unused all weekend | 0 | 0 UoI |
A whole day of fairly heavy use of a Medium model typically costs well under a dollar. 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 a few minutes while it wakes up — 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.
Summary
- One flat price per million tokens, based only on the size of your model — reading and writing billed at the same rate.
- Small ($0.60) → Largest ($30.00) per 1M tokens; see the table above.
- No standing charges — a model that nobody uses costs nothing.
- First message after idle waits 5–10 minutes for the free automatic wake-up; afterwards replies are at normal speed.
- 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) and visible per model in the workspace dashboard.