The short answer
If you want llm free api access with no limit and no bill, this is not that service, and you should be suspicious of anyone who promises it. Running a large language model costs real money in GPU time, so a hosted endpoint either charges per token, caps you hard, or pays for itself some other way. What this API offers is a trial: after sign-up you claim $0.50 of credit with one click on the API key page. It is one per person, it is valid for 7 days, and you pay nothing to claim it.
After that the model is pay as you go. You buy prepaid credit, you spend it at $0.15 per 1M input tokens and $0.50 per 1M output tokens, and there is no monthly fee waiting behind it. Because the per-token rates are low, $0.50 goes a lot further than it sounds. The sections below put actual numbers on it so you can decide whether the trial is enough for your test, and what a real workload costs once it is not.
The endpoint is OpenAI-compatible, so trying it means changing a base URL and a key in code you probably already have. You can read the setup details on the quickstart page, and the price list lives on the pricing page.
What $0.50 of trial credit buys
Token prices are quoted per million, which is hard to feel. A simpler way is to price one request, then divide. A token is a few characters of text, so 1,000 tokens is roughly a page of plain prose. Take a request with 1,000 input tokens and 500 output tokens:
- Input: 1,000 tokens x $0.15 / 1,000,000 = $0.00015
- Output: 500 tokens x $0.50 / 1,000,000 = $0.00025
- Total: $0.0004 per request
Divide the trial by that: $0.50 / $0.0004 = 1,250 requests. That is enough to build a prototype, run a few hundred test prompts, and still have credit left over for a demo. The table below shows the same arithmetic for four common request shapes.
| Request shape | Input / output tokens | Cost per request | Requests in $0.50 |
|---|---|---|---|
| Short classification | 300 / 20 | $0.000055 | about 9,090 |
| Standard test prompt | 1,000 / 500 | $0.0004 | 1,250 |
| Chat turn with history | 3,000 / 700 | $0.0008 | 625 |
| Long document pass | 80,000 / 2,000 | $0.013 | 38 |
The long document row shows where the trial runs out quickly: big prompts. Filling the whole 100,000 token context window with input alone costs 100,000 x $0.15 / 1,000,000 = $0.015, so the trial would cover about 33 requests that size before you even count the answers.
Trial limits you should know about
The trial key is deliberately smaller than a full key. It allows 2 concurrent requests and 60 requests per minute, against 8 concurrent and 300 per minute on a full key. For manual testing and a single script this is plenty. It will bite if you point a batch job with many workers at it.
When you exceed a limit the API answers with HTTP 429. The error code is rate_limited when you went over requests per minute and concurrency when too many requests were in flight at once. Streaming matters here: a streamed request holds its concurrency slot until the stream ends, so two long streams can block a third request even if you are far below 60 per minute. If you see concurrency errors on a trial key, lower your worker count to 2.
The trial lasts 7 days from the claim, so claim it when you are ready to test, not when you first create an account. Sign-up works with Google or with an email and password, and the claim button is on the API key page.
What a real workload costs after the trial
Three examples with the math written out, so you can swap in your own numbers.
A chat app with history
Each turn sends about 3,000 tokens of system prompt and history and gets 700 tokens back. That costs 3,000 x $0.15 / 1M = $0.00045 for input plus 700 x $0.50 / 1M = $0.00035 for output, so $0.0008 per message. A thousand messages cost $0.80. A user who sends 40 messages a day costs you $0.032 a day, about $0.96 over a 30-day month.
A batch job
Say you process 10,000 records, each with 1,500 tokens in and 300 tokens out. Input is 15,000,000 tokens, which is 15 x $0.15 = $2.25. Output is 3,000,000 tokens, which is 3 x $0.50 = $1.50. The whole run is $3.75. Notice that output is only a sixth of the tokens here but 40% of the bill, because output costs more than three times as much per token as input.
Long-context analysis
Reading an 80,000 token document and writing a 2,000 token summary costs $0.012 for input and $0.001 for output, so $0.013. Run it on 100 documents and you have spent $1.30.
Failed or refused requests are not charged, so a request that errors out does not eat into these totals. Every response carries an X-Balance-USD header, which lets you watch the remaining balance from your own code instead of guessing.
What a $20 top-up covers
The minimum top-up is $20, and you can add any whole amount up to $500. Larger top-ups carry a bonus: +5% from $50, +10% from $100 and +15% from $200. In practice that means $50 gives you $52.50 of credit, $100 gives $110 and $200 gives $230. Payment is in crypto only, USDT on TRC20 or USDC on Base, and the credit never expires, so there is no pressure to spend it in a month.
At $20 with no bonus, the same four request shapes from the table work out like this:
- Short classification at $0.000055: about 363,636 requests
- Standard test prompt at $0.0004: 50,000 requests
- Chat turn at $0.0008: 25,000 requests
- Long document pass at $0.013: about 1,538 requests
For most side projects, $20 is months of usage. Check the pricing page for the current top-up options before you pay.
Ways to stretch free credit further
A few habits cut the bill without changing what your app does.
- Trim history. Input tokens are the cheap side, but a chat that resends 20,000 tokens of old turns on every message adds up. Summarize or drop old turns.
- Cap output where it makes sense.
max_tokensis optional, but setting it for short tasks such as classification stops a rambling answer from costing five times what you expected. - Use stop sequences. The
stopparameter ends generation at a marker you choose. - Keep prompts stable while testing. The
seedparameter helps you compare runs of the same prompt, so you do not burn credit chasing noise. - Read your own usage. Log the
usageblock from each response and multiply it by the two rates. A five-line helper makes cost visible from day one.
IN_PER_M, OUT_PER_M = 0.15, 0.50
def cost_usd(usage):
return (usage.prompt_tokens * IN_PER_M
+ usage.completion_tokens * OUT_PER_M) / 1_000_000
# resp = client.chat.completions.create(...)
# print(f"${cost_usd(resp.usage):.6f}")If you want to try this against the real endpoint, set the base URL to https://api.nsfwvideogenerator.cc/v1, use the model ID uncensored, and send your key as a Bearer token. The quickstart has a working example in Python, Node and curl.
Free alternatives and when they make sense
Being straight about this: the trial is not the only route. Open-weight models can be run on your own hardware, which has no per-token fee but needs a machine with enough memory and your time to set it up and keep it running. Some providers also advertise free tiers, with their own rate limits and policies, so check their current pricing and terms rather than trusting a summary.
The reason to use a hosted prepaid endpoint instead is simple. You get a model that is tuned to answer without content refusals for lawful adult use, a stable OpenAI-compatible interface, and a price you can compute on a napkin. The hard limit stays in place: no sexual content involving minors. The service is text only, so it will not generate images, audio or video, and it does not offer embeddings or fine-tuning. If your project is a text pipeline, such as scripts and prompts for downstream tools described on the NSFW pipelines page, that is exactly the slice you need.
Prompts are not used for training, which is worth knowing before you paste real project material into any hosted API.
