Chamadas à API Unlimited AI: limites explicados
Você pode fazer chamadas ilimitadas à API? Não há cota mensal nesta API, mas existem dois limites de taxa: requisições por minuto e simultâneas. Veja o que significam na prática e como escrever código que respeita esses limites.
Atualizado
Pontos principais
- Uma chave completa permite 300 requisições por minuto e 8 requisições simultâneas; uma chave de teste permite 60 e 2.
- 429 com código rate_limited significa excesso por minuto; código concurrency significa excesso de simultaneidade.
- Uma requisição em streaming ocupa sua vaga de concorrência até o fim do stream.
- Use um semáforo de 8 e faça retry dos 429 com backoff, respeitando o Retry-After.


Os dois limites, lado a lado
Para chamadas de API sem teto mensal, você está coberto: o pagamento é pré-pago e por token, sem cota de chamadas. O que limita a vazão é um par de limites de taxa que protegem as GPUs compartilhadas.
| Tipo de chave | Requisições por minuto | Requisições simultâneas |
|---|---|---|
| Chave completa | 300 | 8 |
| Chave de teste | 60 | 2 |
Outros limites fixos: corpo da requisição de até 8 MB e janela de contexto de 100.000 tokens (prompt mais conclusão). Isso se aplica por requisição, não por minuto.
Os dois limites de taxa são independentes. Você pode exceder o limite de concorrência enviando apenas 20 requisições por minuto se cada uma demorar muito, e pode exceder o limite por minuto com chamadas muito rápidas e curtas.
O que os números significam para cargas reais
Uma maneira rápida de dimensionar sua carga é a lei de Little: requisições simultâneas = taxa de chegada x duração média.
- Chatbot, 100 usuários ativos. Se cada um enviar uma mensagem a cada 60 segundos, isso são 100 requisições por minuto, bem abaixo de 300. Cada resposta leva cerca de 10 segundos, então a concorrência média é (100 / 60) x 10, aproximadamente 17. Isso excede 8, então você precisa de filas, não apenas de um loop de retry.
- Lote de 10.000 prompts curtos. A 300 por minuto, o tempo mínimo de execução é 10.000 / 300 = 33,3 minutos. Para atingir 300 por minuto com 8 vagas, as chamadas devem ter duração média de 1,6 segundos (8 x 60 / 300). Chamadas mais longas deslocam o gargalo para a concorrência: a 8 segundos por chamada, 8 vagas dão 60 chamadas por minuto e o trabalho leva cerca de 167 minutos.
- Desenvolvedor único scriptando. Uma ou duas requisições de cada vez nunca se aproximam de nenhum limite.
A lição é que para gerações longas, a concorrência é quase sempre o limite que você atinge primeiro. Saídas curtas atingem o teto por minuto.
Lendo os cabeçalhos de limite de taxa
Cada resposta carrega cabeçalhos que você pode registrar ou usar para adaptar:
X-RateLimit-Limit-Requests: seu limite por minuto.X-RateLimit-Limit-Concurrency: seu limite de concorrência.X-Balance-USD: crédito restante.X-Request-Id: cite isso ao suporte se algo parecer errado.
Com o SDK Python da OpenAI, use o wrapper de resposta bruta para vê-los:
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)
Verifique isso uma vez na inicialização e dimensione seu pool de workers a partir do valor de concorrência em vez de codificar 8. Assim, o mesmo código funciona para uma chave de teste e uma chave completa.
O que um 429 indica
Ultrapassar um limite retorna HTTP 429 com um código de erro:
rate_limited: muitas requisições por minuto. Reduza a velocidade.concurrency: muitas requisições em andamento. Aguarde uma terminar.
A API também retorna 429 com o cabeçalho Retry-After: 5 quando está temporariamente sobrecarregada. Em todos os casos, a resposta correta é a mesma: aguarde e tente novamente, usando o valor do cabeçalho quando presente.
Uma armadilha com streaming: uma requisição em streaming ocupa seu slot de concorrência até o fim do streaming. Se um cliente abre um stream e depois para de ler, ou uma interface de usuário deixa conexões pendentes, esses slots permanecem ocupados. Sempre feche streams que você abandonar.
Um executor em lote que respeita ambos os limites
Este script mantém no máximo 8 requisições em andamento, espaça os inícios para permanecer abaixo de 300 por minuto, e faz retry dos 429 com backoff. Ajuste CONCURRENCY e RPM para uma chave de teste.
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))
O semáforo é liberado enquanto dorme em um 429, então outras tarefas continuam avançando. Definir max_retries=0 no cliente impede que o SDK faça suas próprias tentativas ocultas por cima das suas.
Dicas de design para alto volume
- Fila, não faça fan-out. Uma fila de tarefas com 8 workers supera criar um thread por requisição e repetir.
- Adicione jitter. Se muitos workers fizerem backoff pelo mesmo tempo, todos retornarão juntos e colidirão novamente.
- Limite a saída. Definir
max_tokensreduz a duração da chamada, o que aumenta a vazão efetiva sob o limite de concorrência. - Prefira menos prompts, porém maiores quando a tarefa permitir, por exemplo, classificando 20 itens por requisição em vez de um. Isso reduz a contagem de requisições por 20x. Cuidado com a janela de 100.000 tokens.
- Acompanhe o custo junto com a velocidade. A $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, um trabalho de 10.000 requisições com 2.000 tokens de entrada e 300 de saída custa $4,50. Veja a página de preços para valores de recarga e bônus.
Se os limites da chave completa forem baixos demais para o seu produto, informe isso através da página de suporte com sua taxa de requisições esperada e comprimento médio de saída.
Erros comuns que parecem limites
Algumas falhas parecem limitação de taxa, mas têm outra causa.
Tempestades de repetição
Um cliente que repete instantaneamente em cada 429 piora o problema. Dez workers repetindo sem atraso mantêm o contador por minuto no teto, então nenhum deles consegue sucesso. Backoff com jitter não é opcional em volume.
Contando requisições, não tentativas
Suas repetições contam como requisições também. Se seu plano é 300 por minuto e 20% das chamadas são repetidas, sua demanda real é 360. Orçone isso executando o loop inicial em cerca de 80% do limite, por exemplo 240 por minuto.
Tempos limite que cancelam trabalho
Se seu cliente desistir após 30 segundos, mas o servidor ainda estiver gerando, você pode abrir uma requisição de substituição enquanto a primeira ainda segura um slot. Defina tempos limite do cliente acima da sua geração mais longa esperada, ou reduza max_tokens.
Teste manual rápido
Para acionar um limite propositalmente com uma chave de teste, dispare três requisições ao mesmo tempo:
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
Em uma chave de teste (2 simultâneas), você deve ver duas respostas 200 e uma 429.
Para onde ir a seguir
Obtenha uma chave na página de chave de API; o crédito de teste com um clique é suficiente para testar sua lógica de repetição contra 429s reais, já que os limites de 60 por minuto e 2 simultâneos da chave de teste são fáceis de atingir de propósito. A documentação lista todos os endpoints, e as notas do LangChain e agentes mostram como limitar a concorrência dentro de frameworks de agentes, onde uma tarefa de usuário pode gerar várias chamadas paralelas.
Mais guias
Perguntas e respostas
Existe um limite diário ou mensal de chamadas na API?
Não. O faturamento é pré-pago por token e não há cota de chamadas. Apenas os limites por minuto e de concorrência se aplicam.
O que acontece quando excedo 300 requisições por minuto?
A API retorna HTTP 429 com o código de erro rate_limited. Aguarde e tente novamente, usando o cabeçalho Retry-After se ele estiver presente.
Por que recebo um erro de concorrência com baixo tráfego?
Gerações longas e streams abertos seguram um slot até o fim. Oito requisições lentas são suficientes para preencher uma chave completa, então limite max_tokens e feche streams não utilizados.
As respostas 429 são cobradas?
Não. Requisições falhas ou recusadas não são cobradas.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.