Jump to a section
Compare published API prices without pretending they are performance results. Choose a task shape and two to six current models, calculate scenario costs, then optionally load your own repeated same-prompt measurements. The site makes no model calls, requests no keys and publishes no invented benchmark rankings.
Article published October 22, 2026 · Model specifications and prices separately verified .
What this comparison can and cannot answer
Most model comparisons collapse several questions into one ranking. The useful starting point is more precise: what would this exact workload cost under each provider's published standard API rate? The interactive lab answers that calculation. It does not know how many tokens a real model will consume, how quickly it will answer, or whether it will succeed on your task. Those require controlled, repeated measurements.
This article compares API model IDs, not subscription products. Availability varies by account and region. The model registry includes GPT-6 Astra, GPT-6.1 Sol, GPT-6 Luna, GPT-5.6 Sol, Claude Fable/Opus/Sonnet/Haiku 5.x, Gemini 4 Argon and Gemini 3.8 Flash only where the vendor publishes the ID and price. It does not silently substitute another model.
Interactive research tool
Compare a workload
Choose two to six official API models. Costs below are calculated scenarios, not measured benchmarks.
Compare whether the answer needs editing, not only its generated length.
Only apply a cache-hit share if your actual usage reports one. Google remains uncached in this scenario because its implicit/explicit caching and storage charges cannot be represented by a universal hit rate. OpenAI/Anthropic cache-write costs are excluded.
Calculated estimate · USD
Published-price cost comparison
| Model | Per request | 1,000 requests | 30-day total |
|---|---|---|---|
| GPT-6.1 Sol | $0.01 | $11.40 | $34.20 |
| Claude Sonnet 5.5 | $0.01 | $11.40 | $34.20 |
| Gemini 3.8 Flash | $0.004275 | $4.28 | $12.82 |
Under these equal token-count assumptions, Gemini 3.8 Flash has the lowest published-price estimate, $21.38 less than the next selected model over 30 days. This does not establish which model completes the task best or uses the fewest real tokens.
Standard paid text API rates as verified October 22, 2026. Input is capped at 100,000 tokens to stay within Claude Haiku 5.5's lower-rate tier. Output is capped at 32,000. Estimates exclude cache writes, Google cache storage, tools, media, regional/priority tiers, taxes, retries and provider-specific usage differences. Google Argon rates change after November 30, 2026; Gemini 3.8 Flash after December 31, 2026; GPT-5.6 Sol's promotional rate is confirmed at least through November 21, 2026. Recheck vendor pricing before purchasing.
Official vendor specifications
The model registry
| Model / API ID | Input | Output | Cached input | Context | Max output | Sources |
|---|---|---|---|---|---|---|
| GPT-6 Astragpt-6-astra | $10 | $50 | $1 | 1.05M | 128K | Rate · Model |
| GPT-6.1 Solgpt-6.1-sol | $2 | $10 | $0.1 | 1.05M | 128K | Rate · Model |
| GPT-6 Lunagpt-6-luna | $0.1 | $0.5 | $0.01 | 1.05M | 128K | Rate · Model |
| GPT-5.6 Solgpt-5.6-sol | $4 | $20 | $0.4 | 1.05M | 128K | Rate · Model |
| Claude Fable 5.1claude-fable-5-1 | $10 | $50 | $0.25 | 1M | 128K | Rate · Model |
| Claude Opus 5.5claude-opus-5-5 | $4 | $20 | $0.2 | 1M | 128K | Rate · Model |
| Claude Sonnet 5.5claude-sonnet-5-5 | $2 | $10 | $0.1 | 1M | 128K | Rate · Model |
| Claude Haiku 5.5claude-haiku-5-5 | $0.1 | $0.5 | $0.01 | 1M | 128K | Rate · Model |
| Gemini 4 Argongemini-4-argon | $2 | $10 | Not modeled | 1,048,576 | 65,536 standard | Rate · Model |
| Gemini 3.8 Flashgemini-3.8-flash | $0.75 | $3.75 | Not modeled | 1,048,576 | 65,536 | Rate · Model |
Vendor-listed API IDs are not proof that every account or region has access. Confirm entitlement before planning a test.
Measurements · local files only
Same-prompt trial data
No Insyto same-prompt model measurements are published yet. Load your own JSON or CSV dataset to inspect measured token use, time to first visible content, total duration and rubric-backed scores. Files stay in this browser session and are never uploaded.
Token-consumption, speed and quality charts remain unavailable until a valid, repeated same-prompt dataset is supplied. The cost chart above is an estimate based on published prices.
Schema: JSON object with schemaVersion: 1 and records, or CSV headers provider,modelId,promptId,promptVersion,trial,startedAt,timeToFirstContentMs,durationMs,inputTokens,outputTokens,status. Optional fields: visibleOutputTokens,reasoningTokens,cachedInputTokens,billedTokens,score,reviewer,evaluationRubric,evaluationRationale,serviceTier,reasoningEffort,apiConfig. Scores need reviewer, rubric and rationale. Status is completed or error.
Token consumption, in plain language
A token is a piece of text as represented by a model's tokenizer. Input tokens include the material sent to the API; output tokens are generated by the model. A cached input token may be billed at a lower rate if a provider actually reports a cache hit. Different tokenizers can split identical text differently, so equal word counts do not imply equal token counts.
A context window limits how much material a request can consider; an output limit caps generation. A model's reasoning or thinking tokens may be billed even when their text is not visible. Never estimate hidden reasoning by subtracting a hand-counted visible answer from a provider total unless its usage schema explicitly supports that interpretation.
Time to first token is often used loosely. A rigorous streaming test records time to the first user-visible content, not the first status or tool event. Total response time runs from request start to completion. Output throughput is visible generated tokens divided by the appropriate generation interval when both measurements exist. None is an energy or carbon metric; this page measures API usage and time, not electricity.
Two APIs with the same $/million input and output rates can have different real cost per successful task: tokenization, output length, hidden reasoning, retries and caching differ. For a decision, divide total spend by the number of outputs that pass an agreed rubric, not just by requests attempted.
A reproducible same-prompt experiment
The benchmark specification in this repository contains ten public, original tasks: factual recall with a reference, long-form explanation, code generation, code debugging, logic, structured extraction, business email, summarization, mathematics and formatting compliance. Each task records an exact prompt, prompt ID/version, evaluation criteria and any checkable reference. No private customer data or paid API calls are involved in this release.
- Freeze the exact prompt text and version before choosing models. Keep the reference answer and scoring rubric separate from generated responses.
- Record the provider, exact API model ID or snapshot, region, service tier, reasoning effort, system instructions, temperature where supported and streaming configuration.
- Run at least three trials per model and task, alternating model order to reduce time-of-day effects. Record errors and retries, not only successful runs.
- Capture first visible streamed content, completion time, input/output usage, reasoning/cache usage where exposed and any actual billing metadata.
- Score correctness, required content and formatting against the task rubric. Record reviewer and rationale; where practical, review outputs without model names.
- Publish medians and ranges, not a single fastest run. Disclose settings that cannot be made equivalent across providers.
The local importer accepts a versioned JSON or CSV schema and requires three completed trials of one prompt version and model configuration before showing medians. Importing a dataset does not make it independently verified. A score requires a named reviewer, explicit rubric and trial-specific rationale; user-supplied measurements remain labeled as such. The local dry-run harness validates the prompt manifest and fixture shape without contacting any provider.
Which model should you test first?
Use the cost lab to choose a small shortlist, then run your own task. For simple routing or extraction, begin with the lower-list-price candidates and check whether they satisfy the rubric. For coding, research or high-stakes decisions, test the task-specific failure modes before buying more expensive capacity. A list-price tie is not proof of equivalent output quality.
For an enterprise deployment, add data handling, access control, auditability, deployment region and procurement constraints. For high-volume automation, count retries and human correction time. A model with a low per-token price but frequent failed outputs may cost more per accepted result. There is no responsible overall winner without comparable success and usage evidence.
Important limitations and pricing conditions
- API results are not directly comparable with ChatGPT, Claude or Gemini subscription experiences. Product routing, tools and quota rules can differ.
- The calculator is a text-only, standard paid API scenario. It excludes tools, images/audio/video, taxes, regional uplifts, priority/batch tiers and provider-specific cache-write/storage charges.
- Google's Gemini 4 Argon and 3.8 Flash standard prices are explicitly time-limited in the official price list. GPT-5.6 Sol also has a promotional period. Reverify before using these rates for a later budget.
- Claude Haiku 5.5 changes price above 100,000 prompt tokens, so this calculator caps input at that threshold. Large-context workloads need a separate tier-aware estimate.
- Even with the same prompt, system messages, tokenizer behavior, reasoning settings, network path and hardware allocation vary. A trial should disclose those differences.
- Vendor comparative labels such as “fast” or “slower” are not cross-vendor latency benchmarks. This page withholds speed and quality rankings until real matched trials are available.
Frequently asked questions
What is an AI token?
A token is a unit a model uses to process text. It is not reliably one word or one character. Providers count input and generated output tokens separately for API billing.
Which model uses fewer tokens?
There is no universal answer. Providers use different tokenizers and models may produce different amounts of text or internal reasoning for the same task. This page does not claim a token-efficiency winner without measured, same-prompt runs.
Why can the same prompt have different token counts?
Tokenizers split text differently, and providers may include system instructions, formatting or hidden reasoning in usage totals. A fair comparison records the exact prompt and each API's returned usage.
Which model is faster?
Published labels such as fast or moderate are not comparable speed measurements. No Insyto cross-provider time-to-first-content or throughput trial is published here. Import repeated runs from your own environment to compare them.
Why might a faster model cost more?
Latency and billing are separate. Output length, reasoning tokens, caching, service tier and price per million tokens all influence cost. Faster responses can still have a higher bill per successful task.
Why do reasoning tokens affect cost?
Some reasoning models use billable tokens that are not part of the visible answer. Where the API exposes those counts, record them; do not infer their number from answer length.
Does GPT-6 Astra cost more than GPT-6.1 Sol?
On the standard paid text API rates verified October 22, 2026, Astra is $10 input and $50 output per million tokens; GPT-6.1 Sol is $2 and $10. For equal billed token counts Astra's listed rate is higher, but real task cost depends on usage and outcome.
How do Claude and GPT-6 prices compare?
Published prices overlap by tier: Claude Fable 5.1 and GPT-6 Astra are both $10 input/$50 output per million, while Claude Sonnet 5.5 and GPT-6.1 Sol are both $2/$10 on the standard rate verified here. Equal list prices do not imply equal real usage or quality.
Are ChatGPT subscriptions priced per token?
Consumer and team subscriptions follow their own plan rules. This calculator covers standard paid API text-token rates; a ChatGPT plan or Claude/Gemini app subscription is not equivalent to an API model ID.
How can I test a model on my task?
Write one exact prompt and objective scoring rubric, run it at least three times per model under recorded settings, capture API usage and timings, and review the outputs blind where possible. Use the local dry-run dataset and import schema before any authorized paid experiment.
Sources and verification
Primary sources were checked on October 22, 2026. Follow the linked vendor pages for updates after that date.
- OpenAI API model catalog — Model IDs and specifications
- OpenAI API pricing — Standard text token and cached-input rates
- GPT-5.6 Sol model documentation — Promotional date and long-context pricing condition
- Claude model overview — API IDs and context specifications
- Claude API pricing — Base and cache-hit token rates
- Claude Haiku 5.5 model documentation — 100,000-token price threshold
- Gemini API pricing — Paid standard rates and future rate changes
- Gemini 4 Argon model documentation
- Gemini 3.8 Flash model documentation
