Mistral AI API Pricing vs an Uncensored Pay-Per-Token API

The short answer

If you are looking up mistral ai api pricing, the honest answer is that there is no single number. Mistral prices each model separately, usually with one rate for input tokens and a higher one for output tokens, and the list changes when models are added or retired. Open their pricing page, pick the model you actually plan to call, and write down both rates per 1M tokens.

The API on this site has one model and one price: $0.15 per 1M input tokens and $0.50 per 1M output tokens. You top up prepaid credit, spend it down, and nothing renews. The rest of this article gives you the formula, a set of worked examples at those two rates, and a short script that measures your own traffic, so you can put any other vendor's numbers next to ours and see the difference in dollars.

One thing to settle first: this is not the official Mistral API. It is an independent service that runs one open-weight model, tuned to answer without content refusals for lawful adult use. If you need a specific official Mistral model by name, this is the wrong product and the comparison below will not change that.

How a per-token bill is built

A language model API counts text in tokens, which are word fragments. A short English word is often one token and a long or unusual word is several. You pay for two streams: the tokens you send (the prompt, including system message and chat history) and the tokens the model writes back (the completion). Output tokens cost more because generating them takes more compute than reading the prompt.

The formula is the same everywhere:

cost = input_tokens / 1,000,000 x input_rate + output_tokens / 1,000,000 x output_rate

Two habits make estimates more accurate. First, count the whole prompt on every call. A chat application resends the full history each turn, so the tenth message in a conversation carries the first nine as input. Second, remember that the context window is shared: here it is 100,000 tokens for prompt plus completion together, and a completion can use whatever the prompt leaves free.

Worked examples at $0.15 and $0.50

The table below uses this API's rates. Each row shows the arithmetic, so you can swap in another vendor's rates and redo it.

Workload	Tokens in / out	Math	Cost
One chat turn	2,000 / 500	0.0003 + 0.00025	$0.00055
10,000 chat turns	20M / 5M	3.00 + 2.50	$5.50
Summarize one long document	50,000 / 1,000	0.0075 + 0.0005	$0.008
Fill the whole window once	98,000 / 2,000	0.0147 + 0.001	$0.0157
Small app, one month	5M / 2M	0.75 + 1.00	$1.75
Busy app, one month	200M / 50M	30.00 + 25.00	$55.00

Look at the third row. Reading a 50,000-token document costs less than a cent, because input is the cheap side. The expensive side is long answers. A workload that generates a lot of text, such as fiction, roleplay or bulk drafting, is dominated by the $0.50 rate, so estimate your output volume carefully and look beyond the number of prompts.

Turning a budget into requests

The smallest top-up is $20. At the chat-turn size above ($0.00055 each) that is about 36,000 turns. Larger top-ups carry a bonus: +5% from $50, +10% from $100 and +15% from $200. So $50 buys $52.50 of credit, $100 buys $110, and $200 buys $230. Top-ups are any whole amount from $20 to $500.

What to compare besides the headline rate

Two APIs with the same per-token rate can still cost very different amounts. These are the items worth checking on any pricing page, ours included.

• Which model you are paying for. A cheaper rate on a smaller model is not a saving if you need to rerun answers. Test your own prompts on each candidate.
• Refusals and retries. If a model declines a lawful request and you have to rephrase and resend, you pay for the extra attempts on most services. Here, failed or refused requests are not charged.
• Billing model. Prepaid credit with no subscription means an idle month costs nothing. Credit here never expires.
• Free allowance. Free tiers are meant for trying things out and usually come with tight rate limits. See how to get an API key for the trial credit available here, and check what Mistral currently offers on their side.
• Rate limits. A low price is no use if you hit a ceiling at launch. A full key here allows 8 concurrent requests and 300 requests per minute; a trial key allows 2 and 60.
• Minimum spend. Prepaid services have a floor. Ours is $20.

When Mistral's own API is the better choice

Sometimes the right answer is to stay with the vendor. Choose Mistral directly if you need one of their named models for a policy or reproducibility reason, if you need features this service does not offer such as embeddings, image input or fine-tuning, or if your company requires a contract and support terms with the model's maker. This API is text only: chat completions and a model list, nothing else.

Choose an independent endpoint like this one when the deciding factors are different: you want answers without content refusals for lawful adult use, you prefer paying per token from a prepaid balance, or you already have code written against the OpenAI SDK and want to change two settings instead of rewriting a client. The page on the uncensored Mistral-style API explains the model side in more detail.

There is also a hard limit worth stating plainly: the service does not produce sexual content involving minors, under any framing, and no pricing tier changes that.

Measure your own traffic before you decide

Estimates from a table only go so far. The better method is to send a day of real prompts and read the token counts the API reports. Every non-streaming response includes a usage object, and streamed responses report usage at the end. The script below adds up a batch and prints the bill at this API's rates. To compare, change the two rate constants to whatever the other vendor currently lists.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.mistralapi.com/v1",
    api_key="YOUR_API_KEY",
)

IN_RATE = 0.15   # dollars per 1M input tokens
OUT_RATE = 0.50  # dollars per 1M output tokens

prompts = [
    "Summarize the plot of Hamlet in five sentences.",
    "Write a product description for a steel water bottle.",
    "Explain what a mutex is to a new developer.",
]

tin = tout = 0
for p in prompts:
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": p}],
    )
    tin += r.usage.prompt_tokens
    tout += r.usage.completion_tokens

cost = tin / 1e6 * IN_RATE + tout / 1e6 * OUT_RATE
print(f"in={tin} out={tout} cost=${cost:.6f}")
print("per 1,000 requests: $%.4f" % (cost / len(prompts) * 1000))

Run it against a few hundred prompts from your real logs, not three toy ones. Then multiply by your monthly request count. The X-Balance-USD response header also shows your remaining credit after each call, which is a handy cross-check against the numbers you computed. Full request details are in the quickstart, and the current rate card is on the pricing page.

Three budgets, three kinds of user

Abstract rates are hard to feel, so here are three realistic profiles, each computed at $0.15 and $0.50 per 1M tokens.

The hobbyist

A person who chats for half an hour a day, about 30 turns with 3,000 input tokens and 300 output tokens each. One turn costs 0.00045 + 0.00015 = $0.0006. Thirty turns a day for 30 days is 900 turns, so $0.54 for the month. The smallest top-up of $20 would last years at that pace, and since credit never expires, that is not a problem.

The support bot

A small shop answering 1,500 tickets a day, each with 1,200 input tokens (policy text plus the customer message) and 250 output tokens. One ticket costs 0.00018 + 0.000125 = $0.000305. A day is $0.4575, and a 30-day month comes to about $13.73. Here the system prompt is the biggest input cost, so shortening it pays off directly.

The batch processor

A pipeline that tags 100,000 documents, each 2,000 tokens in and 200 tokens out. Input is 200M tokens, which is $30.00. Output is 20M tokens, which is $10.00. The whole job is $40.00, and you can see the bill before you run it by multiplying a sample.

These profiles show why the rate card alone is not enough. The hobbyist cares about the minimum top-up, the support bot about prompt length, and the batch job about the output rate and the concurrency limit. A full key allows 8 requests at once, so a batch of 100,000 documents is a question of throughput as much as price.

Common mistakes when comparing prices

• Comparing only the input rate. Many applications spend most of their money on output. Always compare both columns.
• Ignoring history growth. A chat with a long memory sends the same early messages again and again. Trim or summarize old turns if cost matters.
• Forgetting the system prompt. A 1,500-token instruction block is billed as input on every single request.
• Using tokens from one tokenizer to estimate another. Different models split text differently. Use the counts the API returns, not a word count times a guess.
• Mixing up a free allowance with production capacity. A free tier answers the question "does this work?" It rarely answers "will this hold up under real traffic?"

More guides

• Mistral API Free Tier: Limits and a Prepaid Alternative
• Uncensored Mistral API: Pay Per Token