EN ▾

Unlimited AI: what it really means

Truly unlimited AI does not exist in the literal sense: every service has a technical cap. Here you can see the real limits of this API and what it costs to stay within them.

Uncensored AI: Analysis of Available Options

Updated:

Ramp with traffic light and eight bright lanes merging into a road, symbolizing request limits.

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

LimitFull keyTrial key
Concurrent requests82
Requests per minute30060
Context (prompt + response)100,000 tokens100,000 tokens
Maximum body size8 MB8 MB
ExpirationCredit never expires7 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.

  1. 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.
  2. 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.
  3. 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_tokens for 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.

Other guides

FAQ

Are there limits on the number of messages per day?

Documented caps are 300 requests per minute and 8 concurrent with the full key, 60 and 2 with the trial key.

What happens if I exceed the limit?

The API responds with HTTP 429 and a rate_limited or concurrency code. Wait a few seconds and retry; the rejected request is not charged.

How long is the maximum context?

100,000 tokens total, including prompt and response. If the conversation grows, summarize or delete older messages.

Does the credit expire?

Prepaid credit does not expire. The only exception is the $0.50 trial credit, which lasts 7 days.

Your key is one form away

Create an account, copy the key, edit the base URL. That's all the configuration.