PT ▾
Obter chave de API

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.
Oito canais de pacotes de dados fazendo fila através de um gateway, ilustrando limites de taxa e concorrência da API
Balança com moedas e cubos de token brilhantes, ilustrando o custo por token da API

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 chaveRequisições por minutoRequisições simultâneas
Chave completa3008
Chave de teste602

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_tokens reduz 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.

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.

Obter chave de API