Is there a free unlimited tier?

No. New users can claim a one-click $0.50 trial credit that is valid for 7 days and needs no card. After that you pay per token from prepaid credit.

Do I pay for failed requests?

No. Failed or refused requests are not charged, and the usage block on a successful response shows the exact tokens you were billed for.

Does my credit expire?

No. Prepaid credit never expires, and there is no subscription or monthly minimum.

How much does one million output tokens cost?

$0.50. One million input tokens costs $0.15. A job with 1M in and 1M out costs $0.65 in total.

API Pricing Examples: Token Math for a Text LLM

The formula, in one line

Text models are billed by the token, and input and output have separate prices. On this API they are $0.15 per 1M input tokens and $0.50 per 1M output tokens. The cost of one request is:

cost = input_tokens x 0.15 / 1,000,000 + output_tokens x 0.50 / 1,000,000

It helps to convert the rates to smaller units, because real requests are small. $0.15 per 1M is $0.00015 per 1,000 input tokens. $0.50 per 1M is $0.0005 per 1,000 output tokens. Output costs a bit over three times as much as input per token, so a reply-heavy job weighs more on the bill than a prompt-heavy one of the same size.

Payment is prepaid credit, pay as you go, with no subscription and no minimum monthly spend. Credit never expires. A request that fails or is refused is not charged. A word on what counts as a token: for English prose a rough rule is four characters per token, or about three quarters of a word. The response includes a usage block with exact counts, so use the estimate for planning and the usage block for accounting.

Example 1: a single chat turn

A user sends a 1,000-token prompt (a short system prompt plus a question) and gets a 500-token reply.

Input: 1,000 x $0.15 / 1,000,000 = $0.00015
Output: 500 x $0.50 / 1,000,000 = $0.00025
Total: $0.0004

Four hundredths of a cent. A thousand identical requests cost $0.40, and 50,000 of them cost $20, which is the smallest top-up. If your app is a companion chat or a writing assistant with short replies, this is your baseline.

Example 2: a conversation that resends its history

Chat APIs are stateless, so every turn sends the whole conversation again. That is the number people underestimate. Take a chat with a 400-token system prompt where each user message is 100 tokens and each reply is 200 tokens, running for 10 turns.

Turn 1 sends 400 + 100 = 500 input tokens. Turn 2 sends the previous 300 tokens of exchange as well, so 800. Each turn adds 300. The input sizes are 500, 800, 1,100 and so on up to 3,200 on turn 10:

Total input: 10 x 500 + 300 x (0 + 1 + ... + 9) = 5,000 + 300 x 45 = 18,500 tokens
Total output: 10 x 200 = 2,000 tokens
Input cost: 18,500 x $0.15 / 1,000,000 = $0.002775
Output cost: 2,000 x $0.50 / 1,000,000 = $0.001
Total: $0.003775, about 0.4 cents for the whole conversation

Notice that input tokens (18,500) are almost ten times the output tokens (2,000), yet the two parts of the bill are within a factor of three. History growth is quadratic: double the turns and the input more than doubles. If your chats run long, trim old turns or keep a short summary instead of the full transcript.

Example 3: generating long text

Now the output-heavy case. A script generator takes a 2,000-token prompt (brief, style rules, a few examples) and writes 1,500 tokens.

Input: 2,000 x $0.15 / 1,000,000 = $0.0003
Output: 1,500 x $0.50 / 1,000,000 = $0.00075
Total per script: $0.00105

At that price $20 buys about 19,000 scripts (20 / 0.00105 is just over 19,047). A small studio producing 200 scripts a day spends 200 x $0.00105 = $0.21 a day, or $6.30 over a 30-day month. Even a hundred times that volume is a budget you can reason about on a napkin. For a worked pipeline with this kind of job, see the quickstart.

Example 4: filling the context window

The context window is 100,000 tokens, prompt plus completion. The largest single request you can send is therefore close to 100,000 tokens in total, for example a long document and a short answer. Take 90,000 input tokens and 4,000 output tokens (94,000 in all, safely under the cap):

Input: 90,000 x $0.15 / 1,000,000 = $0.0135
Output: 4,000 x $0.50 / 1,000,000 = $0.002
Total: $0.0155, about a cent and a half

Even the biggest request is cheap in absolute terms, but it is the one to watch in a loop. Run it 1,000 times and you have spent $15.50. A request this size is where the input side finally dominates the bill, and where a retrieval step that sends only the relevant pages pays for itself.

Example 5: a monthly estimate

To budget for a month, estimate the total tokens in each direction rather than the number of requests. Suppose your app processes 5M input tokens and 1M output tokens a month:

Input: 5 x $0.15 = $0.75
Output: 1 x $0.50 = $0.50
Total: $1.25

Flip the ratio to 1M in and 1M out and the total is $0.15 + $0.50 = $0.65. Raise it to 50M in and 10M out and it is $7.50 + $5.00 = $12.50. The tool for doing this in your own code is the usage block, summed per day:

from openai import OpenAI

client = OpenAI(base_url="https://api.vibevoice.top/v1", api_key="YOUR_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 two-sentence product blurb for a desk lamp."}],
)

u = resp.usage
cost = u.prompt_tokens * IN_PRICE + u.completion_tokens * OUT_PRICE
print(u.prompt_tokens, u.completion_tokens, round(cost, 6))

Each response also carries an X-Balance-USD header with your remaining credit. If you read it with the SDK's raw-response mode, you can stop a batch when the balance falls under a threshold and avoid a half-finished job.

Top-ups, bonuses and the trial

Credit is added in whole-dollar amounts from $20 to $500, by card (Visa, Mastercard, Apple Pay, Google Pay) or crypto (USDT on TRC20, USDC on Base). Larger top-ups get a bonus: +5% from $50, +10% from $100 and +15% from $200. The arithmetic:

Top-up	Bonus	Credit you receive
$20	none	$20.00
$50	+5% = $2.50	$52.50
$100	+10% = $10	$110.00
$200	+15% = $30	$230.00
$500	+15% = $75	$575.00

At the baseline of Example 1 ($0.0004 per request), the $230 from a $200 top-up covers 575,000 requests. The full price list lives on the pricing page.

There is no free unlimited tier. What exists is a small trial: after sign-up, new users can claim $0.50 of credit with one click on the API key page. It needs no card, is valid for 7 days and is one per person. At Example 1 prices, $0.50 pays for 1,250 requests (0.50 / 0.0004), and at Example 3 prices for 476 scripts. Trial keys run at 2 concurrent requests and 60 per minute, which is plenty for testing. The key page has the claim button.

Where the money actually goes

When a bill surprises people, it is almost always one of three things. A loop that resends a growing history (Example 2). A long document pasted in on every call when a summary would do (Example 4). Or output that runs longer than needed because the prompt never asked for brevity. Output tokens cost over three times as much as input tokens, so a line such as "answer in at most 120 words" can cut spend faster than shaving the prompt. Setting max_tokens is optional here, but a cap is a cheap safety net in unattended jobs.

Prices on this page apply to one hosted open-weight text model. It does not return images, audio or embeddings, and it is not an official API of any model vendor. For any other service you compare against, check their current pricing yourself rather than trusting a number copied from a blog.