LLM API Prompt Cost: Budget Your Tokens
Prices are $0.15 per 1M input tokens and $0.50 per 1M output tokens. Here is how to turn them into a budget for your own prompts.
Updated

Key points
- A 600-in, 400-out prompt call costs $0.00029; 1,000 calls cost $0.29.
- Output tokens cost 3 and a third times more than input tokens.
- Chat history is resent every turn, so long chats cost far more per turn than short ones.
- Prepaid credit from $20 never expires; there is a $0.50 trial but no free tier.
The short answer, with numbers
On this API, the llm api prompt cost is simple to state: $0.15 per 1 million input tokens and $0.50 per 1 million output tokens. A typical prompt-expansion call, with 600 tokens going in and 400 coming out, costs $0.00029, which means 1,000 such calls cost $0.29. There is no subscription and no monthly minimum. You pay from prepaid credit, and the credit never expires.
The rest of this article shows how to get from those two prices to a budget you can trust: how to count tokens, what long conversations really cost, what a top-up buys, and where a prompt can be trimmed. Every figure below is computed from the two rates, and the arithmetic is shown so you can redo it with your own numbers.
| Job | Input tokens | Output tokens | Cost per call |
|---|---|---|---|
| Prompt expansion | 600 | 400 | $0.00029 |
| Long system prompt, short reply | 2,100 | 300 | $0.000465 |
| Large document in the 100k window | 80,000 | 2,000 | $0.013 |
How tokens become dollars
An LLM bill has two lines. Input tokens are everything you send: the system message, earlier turns of the conversation, any pasted documents and the new question. Output tokens are what the model writes back. Output costs more per token here, $0.50 against $0.15 per million, so each output token is 3 and a third times the price of an input token. A long answer is more expensive than a long question of the same length.
For a single call the formula is:
cost = input_tokens x 0.15 / 1,000,000 + output_tokens x 0.50 / 1,000,000
As a rough rule for English text, one token is about four characters, or three quarters of a word. A 300-word prompt is around 400 tokens. That is only an estimate. Code, numbers and non-English text usually take more tokens per word, so measure a real sample before you budget a large job.
The easiest way to measure is to ask the API. Every response carries a usage object with prompt and completion token counts, and a streamed response sends usage at the end of the stream. Run twenty representative requests, average the two numbers, and multiply.
Worked example: expanding prompts
Take a job that writes a finished text-to-video prompt from a short idea. The system message plus the idea come to 600 input tokens, and the reply is 400 tokens.
- Input: 600 x $0.15 / 1,000,000 = $0.00009
- Output: 400 x $0.50 / 1,000,000 = $0.0002
- Total per call: $0.00029
Scale it up:
- 1,000 calls: $0.29
- 10,000 calls: $2.90
- 100,000 calls: $29.00
Put another way, the $0.50 trial credit covers about 1,724 of these calls (0.50 / 0.00029 = 1,724.1), and a $20 top-up covers about 69,000 of them. For small teams and hobby projects, the cost of the prompts is rarely the part of the budget that hurts. The tool that consumes the prompts usually costs far more.
The trial credit is $0.50, valid for 7 days, claimed with one click on the API key page after sign-up, one per person. It needs no card. There is no recurring free tier beyond that, so plan for prepaid credit once the trial runs out.
Why long chats cost more than you expect
Chat-style use is where estimates go wrong. The API is stateless, so for every new turn you resend the whole conversation. Input grows with each turn even if every message is short.
Say a chat has a 500-token system message. In each turn the user writes 100 tokens and the model replies with 300. Turn 1 sends 600 tokens. Turn 2 sends 600 plus the 400 from turn 1, so 1,000. Each later turn adds 400 more.
- Input over 10 turns: 10 x 600 + 400 x (0 + 1 + ... + 9) = 6,000 + 400 x 45 = 24,000 tokens
- Output over 10 turns: 10 x 300 = 3,000 tokens
- Input cost: 24,000 x $0.15 / 1,000,000 = $0.0036
- Output cost: 3,000 x $0.50 / 1,000,000 = $0.0015
- Total for the ten-turn chat: $0.0051
That is about half a cent for a whole conversation. The amount matters less than the shape: turn 10 costs far more than turn 1, and total input grows with the square of the number of turns. Stretch the same chat to 100 turns and the input becomes 100 x 600 + 400 x 4,950 = 2,040,000 tokens, which is $0.306. The 30,000 output tokens add $0.015, for a total of $0.321. Ten times the turns, about 63 times the cost.
If your use is long-running chat or roleplay, decide when to cut or summarize old turns. Replacing the first 80 turns with a 500-token summary can shrink every later request, and it also keeps the conversation inside the 100,000-token window.
One large request in the 100k window
The other extreme is one huge request: a long manuscript, a log file, a set of transcripts. The window is 100,000 tokens for prompt plus completion together, so the largest input leaves little room for output. A job with 80,000 input tokens and 2,000 output tokens costs:
- Input: 80,000 x $0.15 / 1,000,000 = $0.012
- Output: 2,000 x $0.50 / 1,000,000 = $0.001
- Total: $0.013
Even a request that fills most of the window costs about a cent. Cost is not the reason to avoid long inputs. Speed and quality are: a very long prompt takes longer to process, and facts in the middle of a huge input are easier for any model to miss. If the answer depends on a few paragraphs, send those paragraphs.
The body limit is 8 MB per request, which is far above what fits in the token window, so the token count will be the limit you reach first.
What a top-up buys
Credit is bought in whole dollar amounts from $20 to $500. Larger top-ups add a bonus: 5% from $50, 10% from $100 and 15% from $200.
| You pay | Bonus | Credit added | Prompt-expansion calls (at $0.00029) |
|---|---|---|---|
| $20 | none | $20.00 | about 69,000 |
| $50 | 5% = $2.50 | $52.50 | about 181,000 |
| $100 | 10% = $10 | $110.00 | about 379,000 |
| $200 | 15% = $30 | $230.00 | about 793,000 |
You can pay with crypto (USDT on TRC20, USDC on Base). Since credit never expires, there is no penalty for buying a larger amount and using it slowly, and the bonus makes that choice attractive if you know you will keep using the API. If you are unsure, start with $20. Current rates and the top-up form are on the pricing page.
Failed or refused requests are not charged. If a request errors out or the model declines, you do not pay for it, which matters when you retry in a loop.
Five ways to lower the bill
Because input is the part you control most, start there.
- Trim the system message. Take a job with a 2,000-token system message, a 100-token idea and a 300-token reply. Input is 2,100 tokens, so the call costs 2,100 x $0.15 / 1,000,000 + 300 x $0.50 / 1,000,000 = $0.000315 + $0.00015 = $0.000465. Over 10,000 calls that is $4.65. Cut the system message to 500 tokens and the call is 600 x $0.15 / 1,000,000 + $0.00015 = $0.00009 + $0.00015 = $0.00024, or $2.40 for 10,000 calls. You save $2.25.
- Cap the output. Set
max_tokensto the length you need. It is optional, but a ceiling protects you from a runaway reply. - Ask for the short form. "Reply with the prompt only" removes preambles that you pay for and then delete.
- Batch small questions. Ten short questions in one request share one system message instead of repeating it ten times.
- Summarize old chat turns. As shown above, this flattens the growth curve.
None of this needs special tooling. The check is a script that logs usage from each response.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
IN_PRICE = 0.15 / 1_000_000
OUT_PRICE = 0.50 / 1_000_000
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a 70 word prompt for a rainy street scene."}],
max_tokens=200,
)
u = resp.usage
cost = u.prompt_tokens * IN_PRICE + u.completion_tokens * OUT_PRICE
print(u.prompt_tokens, u.completion_tokens, "tokens, about $%.6f" % cost)
You can also watch the balance directly: each response includes an X-Balance-USD header. Log it next to the request ID from X-Request-Id and you can reconcile spend against your own counts. To begin, claim the trial on the API key page and read the docs for the full parameter list.
More guides
Questions and answers
Is there a free tier?
No. New users can claim a one-time $0.50 trial credit, valid for 7 days and needing no card. After that you pay from prepaid credit.
Do refused or failed requests cost money?
No. Failed or refused requests are not charged.
Does credit expire?
No. Credit never expires, and there is no subscription.
How do I see what a request cost?
Read the usage object in the response for token counts and the X-Balance-USD header for your remaining balance.
Your key is one form away
Create an account, copy the key, change the base URL. That is the whole setup.