Unlimited AI API Calls: Rate Limits Explained
Can you make unlimited ai api calls? There is no monthly quota on this API, but there are two rate limits: requests per minute and requests at once. Here is what they mean in practice and how to write code that stays inside them.
Updated
Key points
- A full key allows 300 requests per minute and 8 concurrent requests; a trial key allows 60 and 2.
- 429 with code rate_limited means too many per minute; code concurrency means too many at once.
- A streamed request holds its concurrency slot until the stream ends.
- Use a semaphore of 8 and retry 429 with backoff, honouring Retry-After.


The two limits, side by side
For unlimited ai api calls in the sense of "no monthly cap", you are covered: billing is prepaid and per token, with no call quota. What limits throughput is a pair of rate limits that protect the shared GPUs.
| Key type | Requests per minute | Concurrent requests |
|---|---|---|
| Full key | 300 | 8 |
| Trial key | 60 | 2 |
Other fixed limits: a request body up to 8 MB and a 100,000 token context window (prompt plus completion). Those apply per request, not per minute.
The two rate limits are independent. You can break the concurrency limit while sending only 20 requests per minute if each one takes a long time, and you can break the per-minute limit with very fast, short calls.
What the numbers mean for real workloads
A quick way to size your workload is Little's law: concurrent requests = arrival rate x average duration.
- Chatbot, 100 active users. If each sends a message every 60 seconds, that is 100 requests per minute, well under 300. Each reply takes about 10 seconds, so average concurrency is (100 / 60) x 10, roughly 17. That exceeds 8, so you need queueing, not just a retry loop.
- Batch of 10,000 short prompts. At 300 per minute the minimum run time is 10,000 / 300 = 33.3 minutes. To reach 300 per minute with 8 slots, calls must average 1.6 seconds (8 x 60 / 300). Longer calls shift the bottleneck to concurrency: at 8 seconds per call, 8 slots give 60 calls per minute and the job takes about 167 minutes.
- Single developer scripting. One or two requests at a time never gets near either limit.
The lesson is that for long generations, concurrency is almost always the limit you hit first. Short outputs hit the per-minute ceiling instead.
Reading the rate-limit headers
Every response carries headers you can log or use to adapt:
X-RateLimit-Limit-Requests: your per-minute limit.X-RateLimit-Limit-Concurrency: your concurrent limit.X-Balance-USD: remaining credit.X-Request-Id: quote this to support if something looks wrong.
With the OpenAI Python SDK, use the raw response wrapper to see them:
from openai import OpenAI
client = OpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY")
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Reply with one word."}],
)
print(raw.headers.get("X-RateLimit-Limit-Requests"))
print(raw.headers.get("X-RateLimit-Limit-Concurrency"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)
Check these once at start-up and size your worker pool from the concurrency value instead of hard-coding 8. That way the same code works for a trial key and a full key.
What a 429 tells you
Going over a limit returns HTTP 429 with an error code:
rate_limited: too many requests per minute. Slow down.concurrency: too many requests in flight. Wait for one to finish.
The API also returns 429 with a Retry-After: 5 header when it is temporarily overloaded. In every case the right response is the same: wait, then try again, using the header value when present.
One trap with streaming: a streamed request occupies its concurrency slot until the stream ends. If a client opens a stream and then stops reading, or a UI leaves connections hanging, those slots stay busy. Always close streams you abandon.
A batch runner that respects both limits
This script keeps at most 8 requests in flight, spaces starts to stay under 300 per minute, and retries 429 with backoff. Adjust CONCURRENCY and RPM for a trial key.
import asyncio, random
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY", max_retries=0)
CONCURRENCY, RPM = 8, 300
sem = asyncio.Semaphore(CONCURRENCY)
interval = 60 / RPM # 0.2 s between starts
async def call(prompt, attempt=0):
async with sem:
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError as e:
if attempt >= 6:
raise
wait = float(e.response.headers.get("Retry-After", 5)) + random.random()
await asyncio.sleep(wait * (1.5 ** attempt))
return await call(prompt, attempt + 1)
async def main(prompts):
tasks = []
for p in prompts:
tasks.append(asyncio.create_task(call(p)))
await asyncio.sleep(interval)
return await asyncio.gather(*tasks)
results = asyncio.run(main(["Summarise: ..."] * 50))
The semaphore is released while sleeping on a 429, so other tasks keep moving. Setting max_retries=0 on the client stops the SDK from doing its own hidden retries on top of yours.
Design tips for high volume
- Queue, do not fan out. A job queue with 8 workers beats spawning a thread per request and retrying.
- Add jitter. If many workers back off for the same time, they all return together and collide again.
- Cap output. Setting
max_tokenslowers call duration, which raises effective throughput under the concurrency cap. - Prefer fewer, bigger prompts when the task allows it, for example classifying 20 items per request instead of one. That cuts request count by 20x. Mind the 100,000 token window.
- Track cost alongside speed. At $0.15 per 1M input and $0.50 per 1M output tokens, a 10,000 request job of 2,000 tokens in and 300 out costs $4.50. See the pricing page for top-up amounts and bonuses.
If the full-key limits are too low for your product, say so through the support page with your expected request rate and average output length.
Common mistakes that look like limits
Some failures feel like rate limiting but have another cause.
Retry storms
A client that retries instantly on every 429 makes the problem worse. Ten workers retrying with no delay keep the per-minute counter pinned at the ceiling, so none of them ever succeeds. Backoff with jitter is not optional at volume.
Counting requests, not attempts
Your retries count as requests too. If your plan is 300 per minute and 20% of calls are retried, your real demand is 360. Budget for it by running the starter loop at about 80% of the limit, for example 240 per minute.
Timeouts that cancel work
If your client gives up after 30 seconds but the server is still generating, you may open a replacement request while the first still holds a slot. Set client timeouts above your longest expected generation, or lower max_tokens.
Quick manual test
To see a limit trigger on purpose with a trial key, fire three requests at the same moment:
for i in 1 2 3; do
curl -s -o /dev/null -w "%{http_code}
" https://api.unlimitedaiapi.com/v1/chat/completions -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" -d '{"model":"uncensored","messages":[{"role":"user","content":"Write a 300 word story."}]}' &
done; wait
On a trial key (2 concurrent) you should see two 200 responses and one 429.
Where to go next
Get a key on the API key page; the one-click trial credit is enough to test your retry logic against real 429s, since the trial key's 60 per minute and 2 concurrent limits are easy to hit on purpose. The docs list every endpoint, and the LangChain and agent notes show how to cap concurrency inside agent frameworks, where one user task can spawn several parallel calls.
More guides
Questions and answers
Is there a daily or monthly limit on API calls?
No. Billing is prepaid per token and there is no call quota. Only the per-minute and concurrency limits apply.
What happens when I exceed 300 requests per minute?
The API answers HTTP 429 with error code rate_limited. Wait and retry, using the Retry-After header if it is present.
Why do I get a concurrency error with low traffic?
Long generations and open streams hold a slot until they finish. Eight slow requests are enough to fill a full key, so cap max_tokens and close unused streams.
Are 429 responses billed?
No. Failed or refused requests are not charged.
Your key is one form away
Create an account, copy the key, change the base URL. That is the whole setup.