Key points
- Uncensored does not mean unlimited: there are caps on requests per minute, concurrent requests and context.
- Full key: 8 concurrent requests and 300 per minute. Trial key: 2 and 60.
- Context is 100,000 tokens between prompt and response; credit never expires.
- A 429 error is handled with a wait and retry, and failed requests are not charged.
Two different things: no refusals and no caps
When looking for AI without usage limits, two ideas are mixed up. The first is the absence of refusals: the model used here is trained to respond without blocks for lawful adult use. The second would be the absence of technical caps, and that does not exist in any serious service. There are limits on request rate, on the number of parallel requests, on context length, and on request body size.
It is worth knowing them before building something, because they are predictable and almost all can be worked around with a bit of code. One limit remains absolute and does not depend on any setting: no sexual content involving minors.
Limits, in a table
| Limit | Full key | Trial key |
|---|---|---|
| Concurrent requests | 8 | 2 |
| Requests per minute | 300 | 60 |
| Context (prompt + response) | 100,000 tokens | 100,000 tokens |
| Maximum body size | 8 MB | 8 MB |
| Expiration | Credit never expires | 7 days |
The response includes the headers X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency, so your code can read the limits instead of hardcoding them. You also get X-Request-Id, useful when contacting support, and X-Balance-USD with the remaining credit.
The max_tokens parameter is optional: the response can use all remaining space in the context window. If the prompt and response space exceed the window, max_tokens is reduced to what remains; the 400 error only occurs when the prompt alone does not fit in 100,000 tokens. In practice, it is better to summarize or delete the old part of a long history, so space remains for the response.
Cost of staying within limits
The rate is $0.15 per 1M input tokens and $0.50 per 1M output tokens. Some concrete calculations, all verifiable.
A typical request
3,000-token prompt and 800-token response:
- input: 3,000 × $0.15 / 1,000,000 = $0.00045;
- output: 800 × $0.50 / 1,000,000 = $0.0004;
- total: $0.00085 per request, so $0.85 per 1,000 requests.
The extreme case
A request that fills the window, e.g. 90,000 prompt tokens and 10,000 response tokens, costs 90,000 × $0.15 / 1M = $0.0135 plus 10,000 × $0.50 / 1M = $0.005, i.e. $0.0185. A thousand such requests cost $18.50. A 100,000-token prompt with a tiny response costs about $0.015.
What you buy with top ups
With $20, the minimum top up, at $0.00085 per request you get about 23,529 requests ($20 / $0.00085 = 23,529.4). The $0.50 free trial credit is enough for about 588 requests of the same type. If you top up $100 you receive $110 in credit, with $200 you receive $230. Top ups range from $20 to $500 and are paid in crypto with USDT on TRC20 or USDC on Base. See details in pricing.
What really limits speed
The number that usually matters is not the 300 per minute, but the 8 parallel requests. A scenario: you process 10,000 documents, each with 2,000 input tokens and 300 output tokens, and each request takes an average of 10 seconds (actual time depends on load and length, measure it yourself).
- With 8 parallel requests you complete 0.8 requests per second, i.e. 48 per minute, well under the 300 cap.
- 10,000 / 0.8 = 12,500 seconds, about 3.5 hours.
- Cost: 20M input tokens = $3.00, 3M output tokens = $1.50, total $4.50.
So the constraint is concurrency, not rate. To shorten times you need shorter requests, not a higher rate. A surprising detail: a streaming request occupies its slot until the end of the stream, so if you leave a forgotten stream open you block one of the 8 slots.
Handling 429 errors
If a limit is exceeded, the API responds with HTTP 429. The error code indicates which: rate_limited for requests per minute, concurrency for concurrent requests. In case of temporary overload, a 429 is always returned with the Retry-After: 5 header. In all three cases, the rule is the same: wait and retry. Failed requests are not charged.
This example limits concurrency to 8 with a semaphore and retries with exponential backoff.
import asyncio, os
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(
base_url="https://api.apiiasenzacensura.com/v1",
api_key=os.environ["API_KEY"],
max_retries=0,
)
slot = asyncio.Semaphore(8) # usa 2 con la chiave di prova
async def chiedi(testo, tentativi=5):
for n in range(tentativi):
async with slot:
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": testo}],
)
return r.choices[0].message.content
except RateLimitError:
pass
await asyncio.sleep(5 * (n + 1))
raise RuntimeError("troppi tentativi")
async def main():
testi = [f"Riassumi in una frase il documento {i}" for i in range(20)]
risultati = await asyncio.gather(*(chiedi(t) for t in testi))
print(len(risultati), "risposte")
asyncio.run(main())
The wait occurs outside the semaphore, so a paused slot doesn't block others. For error format details, see the documentation.
Check credit while working
Since cost is per token, a poorly written loop can consume credit faster than expected. Two cost-saving measures: read the balance and set your own cap.
curl -i https://api.apiiasenzacensura.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"uncensored","messages":[{"role":"user","content":"Ciao"}],"max_tokens":20}'
Response headers include X-Balance-USD. You can also query GET /v1/balance with the same key, or the OpenAI-style endpoint /v1/dashboard/billing/credit_grants. Checking every few requests lets you stop a batch when the balance drops below your threshold. Also set max_tokens on serial jobs to avoid excessively long responses you don't need.
How to make credit last longer
Since cost depends on tokens, the most effective way to spend less is to send fewer. Three habits that almost always work.
- Shorten the history. In a chat, each turn sends the entire past to the model. After 20 turns of 350 tokens each, the history alone weighs 7,000 input tokens for every new question, costing $0.00105 just to re-read it (7,000 × $0.15 / 1M). Summarizing old turns into a few lines cuts this cost.
- Keep the system prompt short. A 1,500-token prompt repeated in 10,000 requests equals 15M input tokens, costing $2.25. Reducing it to 500 tokens brings the cost down to $0.75.
- Cap the responses. Output tokens cost more than three times the input tokens ($0.50 vs $0.15). Asking for concise answers or setting
max_tokensfor tasks that only need two lines is the most direct saving.
Temperature and other sampling parameters, such as top_p or seed, are passed to the model. The seed parameter is useful if you want to repeat a test and compare two prompts more cleanly.
What to say to those promising unlimited
When a service promises unlimited requests without explaining caps, always ask what they are. A model with declared limits and per-token pricing is easier to plan for. Here you know in advance how many requests you can make and how much you will spend, without a subscription and with credit that never expires. To get started, get your key and use the $0.50 free trial credit, which you claim with one click after registration and requires no payment.

