What does the Thinking Machines Inkling API cost per million tokens?

Thinking Machines publishes two separate price lists. Tinker serverless inference for Inkling is $1.00 per million input tokens, $0.17 per million cached input tokens, and $4.05 per million output tokens at the 256K context tier. Inkling-Small, the 276B/12B sibling, is $0.30 per million input, $0.06 cached input, and $1.20 per million output at the same context. The numbers are published as machine-readable JSON at tinker-docs.thinkingmachines.ai/tinker/serverless.json, so they can be pulled programmatically rather than scraped.

Is Inkling open weights, and can I self-host it instead of paying an API?

Yes. Inkling and Inkling-Small are both released with full weights on Hugging Face under the thinkingmachines organisation, so self-hosting is a real alternative to the hosted endpoint. The intended division of labour is that the weights are for people who want to own and modify the model, while Tinker is for people who want to fine-tune without owning GPU infrastructure. Note that Inkling itself is 975B parameters with 41B active per token, so self-hosting means a genuinely large MoE deployment, whereas Inkling-Small at 276B total and 12B active is the practical self-host target.

What is Tinker and how is it different from an ordinary inference API?

Tinker is a training API, not a chat API. Its surface is four functions: forward_backward to run a forward and backward pass and accumulate gradients, optim_step to apply the accumulated gradient, sample to generate tokens for evaluation or RL actions, and save_state to checkpoint. You write LoRA fine-tuning loops against that, and Thinking Machines handles scheduling and the GPU clusters. The practical consequence for budgeting is that Tinker bills per million tokens on prefill, cached prefill, sample, and train, so training a model has its own line item that is distinct from inference. Checkpoint storage is charged separately at $0.10 per GB-month.

How does Inkling-Small compare to Inkling on benchmarks?

Thinking Machines reports that Inkling-Small matches or exceeds its larger sibling on reasoning and agentic tasks. On Humanity's Last Exam it scores 31.6% against Inkling's 29.7%, and the company says the advantage holds at every thinking budget, meaning the test-time compute curve sits above Inkling's throughout. On SWEBench-Verified it exceeds 80%. Inkling retains an advantage on knowledge coverage and factuality, which is the expected trade for a model a quarter of the size. On the GDPval-AA v2 Elo measure, Inkling-Small is credited with 1269 at roughly 23k output tokens per task versus Inkling's 1238 at 28.6k tokens.

Does the Inkling API support images and audio, or only text?

Both models are natively multimodal on input. The model specification lists text, image, and audio as supported inputs, and the Tinker model table types both entries as Hybrid plus Audio plus Vision. What that means in practice is that the documented context window of up to 1M tokens applies across modalities; the hosted serverless tiers, however, are documented at a 256K context rather than the full million. If you need the longest context, check which tier you are being billed against before assuming the headline figure applies.

Is the 50% discount on Inkling training permanent?

No. Thinking Machines labels the current training prices as a limited-time 50% discount, which is why the published table carries both a discounted figure and an original figure for each model. For Inkling at the 64K tier the current prefill is $1.87 against an original $3.74, and the train rate is $5.61 against an original $11.22. The machine-readable JSON exposes these as original_prefill, original_cached_prefill, original_sample, and original_train fields alongside a note field, so you can compute what a workload costs after the discount ends without guessing. Budget against the original rate, not the promotional one.

Thinking Machines Inkling API: Tinker Pricing

An Open-Weights Model Family With a Training API Attached

Thinking Machines Lab released Inkling on July 15, 2026, followed by Inkling-Small on July 30. Both ship with full weights, both are served through Tinker, and both are listed with per-million-token pricing that the company publishes as machine-readable JSON. For anyone maintaining an API cost comparison, that combination is unusual enough to be worth a careful look: most open-weight releases either lack a first-party hosted endpoint, or hide the pricing behind a sales conversation.

This article covers what the two models are, what the hosted endpoints charge, what Tinker's training rates add on top, and where the pricing structure creates traps for a cost model.

The Model Lineup

The two models are Mixture-of-Experts transformers trained from scratch. The headline numbers come straight from the model page and the release posts.

Model	Total params	Active params	Architecture	Context	Inputs
Inkling	975B	41B	MoE	1M tokens	Text, image, audio
Inkling-Small	276B	12B	MoE	1M tokens	Text, image, audio

Inkling was pretrained on 45 trillion tokens of text, images, audio, and video. The company is unusually direct about where it sits competitively: the release post states that Inkling is not the strongest overall model available today, open or closed, and instead argues that the combination of multimodal input, efficient and controllable thinking effort, and Tinker availability makes it a good open-weights base for customisation. That is a positioning statement worth taking at face value when you are deciding between Inkling and a frontier hosted model.

Inkling-Small is the more interesting of the two for most teams. It began training after its larger sibling, which let Thinking Machines adjust the pretraining data mix and recipe, and it was post-trained partly via on-policy distillation with Inkling as the teacher before two further weeks of scaled agentic coding RL. The result, per the company, is a model that surpassed Inkling on reasoning and agentic coding while retaining the multimodal input and variable thinking effort.

Serverless Inference Pricing

This is the price list that matters if you want to call the models rather than train them. Both entries are documented at a 256K context tier, and both are billed per million tokens with a separate cached-input rate.

Model	Context	Input /1M	Cached input /1M	Output /1M
Inkling-Small	256K	$0.30	$0.06	$1.20
Inkling	256K	$1.00	$0.17	$4.05

Two things stand out. First, the cached-input discount is substantial: Inkling-Small's cached rate is one fifth of its input rate, and Inkling's is slightly better than one sixth. For an agent that carries a long system prompt or a persistent skill file, that ratio is the single biggest lever on your bill. Second, the gap between the two models is not uniform. Inkling costs 3.3x Inkling-Small on input but only 3.4x on output, so there is no tier where the larger model is proportionally cheaper to run.

The 256K context in the pricing table is worth flagging separately. The model page advertises a 1M-token context window, and the release post repeats that figure. The serverless table documents 256K. If your workload depends on the headline number, confirm which tier you are actually being routed to before you size the context budget.

Tinker Training Pricing

Tinker is the part of the offering that has no direct equivalent in most API catalogs. It is a training API built on LoRA fine-tuning, exposed through four functions: forward_backward, optim_step, sample, and save_state. You bring a dataset of supervised examples or reinforcement-learning environments, pick a base model, and Thinking Machines handles scheduling and the GPU clusters behind the API.

Pricing is per million tokens across four line items: prefill, cached prefill, sample, and train. The current rates carry a limited-time 50% discount, which the published table exposes by showing both the discounted and the original figure.

Base model	Context	Prefill /1M	Cached prefill /1M	Sample /1M	Train /1M
Inkling	64K	$1.87	$0.374	$4.68	$5.61
Inkling (256K)	256K	$3.74	$0.748	$9.36	$11.23
Inkling-Small	64K	$0.58	$0.116	$1.44	$1.73
Inkling-Small (256K)	256K	$1.16	$0.232	$2.89	$3.47
Nemotron-3-Ultra-550B-A55B	64K	$2.49	$0.498	$6.225	$5.478
Nemotron-3-Super-120B-A12B	64K	$0.57	$0.114	$1.44	$1.276
GLM-5.3	256K	$4.86	$0.972	$12.15	$14.58
Kimi-K2.6	32K	$2.205	$0.441	$5.49	$4.84
Qwen3.8-27B	64K	$1.86	$0.372	$5.595	$4.103
GPT-OSS-120B	32K	$0.33	$0.066	$0.84	$0.737
Qwen3-8B	32K	$0.195	$0.039	$0.60	$0.44
DeepSeek-V3.1	32K	$1.695	$0.339	$4.215	$3.718

Note that training a model is not restricted to Thinking Machines' own weights. The base-model roster independently includes NVIDIA Nemotron variants, Z.AI GLM-5.3, Moonshot Kimi-K2.6, five Qwen checkpoints, OpenAI's GPT-OSS pair, and DeepSeek-V3.1. That makes Tinker a plausible substitute for a self-managed fine-tuning stack even if you have no interest in Inkling itself, which is the more commercially relevant reading of the product.

Checkpoint storage is billed separately at $0.10 per GB-month. Tinker also exposes an endpoint for downloading any saved checkpoint, so fine-tuned weights are portable off the platform rather than trapped on it. On the data question, Thinking Machines states that customer training data is used solely to fine-tune the customer's own models and is not used to train Thinking Machines' models.

Why the Machine-Readable Pricing Matters

The documentation page carries a note that is, for anyone building a cost dashboard, more useful than the tables themselves. It warns against scraping the HTML, states that the tables are presentational and may change, and points instead at two JSON files published alongside the page.

models.json covers the training table. Each object carries name, tinker_id, context, size, params, active_params, arch, type, url, and the four per-million-token prices as strings. Models on a temporary discount additionally carry original_prefill, original_cached_prefill, original_sample, and original_train fields plus a note. serverless.json covers the inference table with input, cached_input, and output.

Two details in that schema are worth building around. The params and active_params values are integers rather than abbreviated strings, and the documentation states they are as published by the model's publisher, with the two values equal for dense models. The price fields are strings with a dollar sign, not floats, so a parser has to strip the symbol before doing arithmetic. The presence of paired original and discounted fields also means you can compute the post-promotion cost of a workload directly from the feed instead of maintaining a parallel table of your own.

Where the Two Models Actually Land

The benchmark story is the reason Inkling-Small is the more strategically interesting release. Thinking Machines' own summary is that Inkling-Small matches or exceeds Inkling on reasoning and agentic tasks while Inkling keeps an advantage on knowledge coverage and factuality.

The specific figures the company publishes: Inkling-Small scores 31.6% on Humanity's Last Exam against Inkling's 29.7%, with the advantage holding at every thinking budget, meaning Inkling-Small's test-time compute curve sits above Inkling's across the sweep. On SWEBench-Verified it exceeds 80%. On the GDPval-AA v2 Elo measure it is credited with 1269 against Inkling's 1238, achieved at roughly 23k output tokens per task versus Inkling's 28.6k.

Two caveats belong with those numbers. They are vendor-reported, and the comparison set in the published charts includes DeepSeek V4 Flash, Gemini 3.5 Flash-Lite, GPT 5.6 Luna, Qwen3.5-397B-A17B, MiMo V2.5, MiniMax M2.7, Kimi K2.5 and K2.6, GLM 5.2, and the Nemotron 3 tiers, so any cross-vendor read should be treated as indicative rather than settled. The token-count figures underlying the cost charts come from Thinking Machines' own evaluations or from Artificial Analysis, which the company discloses.

The Trade-Offs to Weigh Before You Commit

The discount is temporary. Every Inkling and Nemotron row in the training table carries a limited-time 50% discount note. Inkling's 64K train rate of $5.61 doubles to $11.22 when that lapses. A cost model built on the promotional rate will be wrong within months, so build on the original fields.

Context varies by surface. The models advertise 1M tokens. The serverless table documents 256K. The training table offers 64K and 256K tiers at different prices. Three surfaces, three numbers, and the price moves with the tier. This is the most likely source of an estimate that is off by a factor of two.

Self-hosting and hosting are different products. The weights being open means self-hosting is real, but Inkling at 975B total parameters is not a casual deployment. Inkling-Small at 276B total and 12B active is the tier where self-hosting starts to make economic sense, and it is also the tier that beats the larger model on the reasoning benchmarks. The sensible default for most teams evaluating this family is Inkling-Small for both API calls and any self-host plan.

Tinker's value is not limited to Inkling. The base-model roster spans eight vendors' checkpoints, so the training API stands on its own. If your interest is LoRA fine-tuning without owning GPUs, evaluate Tinker against your current stack on that basis and treat Inkling as one model option inside it rather than as the reason to sign up.

Not every model carries the discount. GLM-5.3, Kimi-K2.6, Qwen3.8-27B, Qwen3.6-27B, Qwen3.5-397B-A17B, the Qwen3.5 base and small models, Qwen3-8B, GPT-OSS-120B, GPT-OSS-20B, and DeepSeek-V3.1 are all listed at full price with no note. The discounted set is Inkling, Inkling-Small, and the four Nemotron checkpoints. If you were assuming a flat promotional rate across the catalog, that assumption is wrong.

The Bottom Line

Thinking Machines has shipped something structurally different from the usual model release: a small open-weight family whose pricing is published in a parseable format, paired with a training API whose base-model roster extends well beyond the company's own weights. The rate card itself is competitive for the parameter counts involved, particularly Inkling-Small at $0.30 input and $1.20 output, and the cached-input ratios are aggressive enough to matter for long-context agent workloads.

The three things to verify before you build a budget on it are the tier you are actually billed at, whether the discount is still in force for the specific models you plan to use, and whether Tinker's training rates beat your current fine-tuning path once checkpoint storage is included. All three are answerable from the published JSON rather than from the marketing page, which is more than can be said for most vendors in this category.

Tinker serverless inference: Inkling $1.00 input / $0.17 cached / $4.05 output per 1M at 256K; Inkling-Small $0.30 / $0.06 / $1.20
Machine-readable pricing: tinker-docs.thinkingmachines.ai/tinker/models.json and serverless.json
Discounts are temporary and flagged with paired original_* fields; budget against the original rates
Checkpoint storage $0.10 per GB-month; checkpoints are downloadable, so fine-tuned weights stay portable