PT ▾

O que é limite de requisições? Limites, retries, contexto

Um limite de requisições limita o tráfego que uma chave pode enviar para uma API em um determinado tempo. Esta página explica o que é um limite de requisições na prática, como contorná-lo e quais são os limites desta API.

Atualizado

Portão com oito faixas passando pacotes leves, ilustrando limites de requisições e concorrência

Pontos principais

  • Um limite de requisições restringe requisições por minuto ou requisições em andamento, para que um cliente não sobrecarregue o serviço.
  • Limites de requisições não são iguais à janela de contexto: um limita o tráfego, o outro limita o tamanho de uma única requisição.
  • Chave completa: 8 requisições simultâneas e 300 por minuto. Chave de teste: 2 simultâneas e 60 por minuto.
  • Lide com limites usando um limite de concorrência, retries com backoff e uma análise dos cabeçalhos de resposta.

O que é um limite de requisições

Então, o que é um limite de requisições? É uma regra que define quantas chamadas uma conta ou chave pode fazer em uma janela de tempo, ou quantas podem ser executadas simultaneamente. Se você ultrapassar o limite, o servidor recusa as chamadas extras em vez de atendê-las. A maioria das APIs HTTP sinaliza isso com o código de status 429 (Muitas Requisições), e muitas adicionam um cabeçalho informando quando tentar novamente. Verifique a documentação de cada serviço para saber o comportamento exato.

Os limites existem porque um servidor de modelo tem uma quantidade fixa de computação. Sem eles, um script em um loop contínuo poderia desacelerar todos os outros. Para você como desenvolvedor, isso significa duas coisas: seu código deve esperar recusas e se recuperar delas, e seu design deve distribuir o trabalho em vez de dispará-lo tudo de uma vez.

Os três tipos de limite que você encontrará

Os provedores combinam esses limites, então leia quais se aplicam à sua chave.

TipoO que é contadoEfeito típico
Requisições por minutoChamadas iniciadas em um minuto móvelPicos são recusados mesmo se cada chamada for pequena
ConcorrênciaChamadas em andamento no mesmo momentoWorkers paralelos além do limite são recusados ou enfileirados
Cota de tokens ou gastosTokens ou dinheiro usados por minuto, dia ou mêsPrompts grandes atingem o limite mais cedo do que prompts pequenos

A concorrência é mais importante para modelos de linguagem do que para APIs comuns, porque uma única conclusão pode levar vários segundos. Dez workers aguardando uma resposta longa mantêm dez vagas ocupadas o tempo todo.

Os limites desta API

Esta API limita requisições por minuto e concorrência, por chave:

Tipo de chaveRequisições simultâneasRequisições por minuto
Chave completa (com crédito)8300
Chave de teste260

Vale a pena conhecer outros dois números. O corpo da requisição máximo é 8 MB, e toda resposta traz cabeçalhos que você pode ler: X-Request-Id para identificar uma chamada quando solicitar ajuda, X-Balance-USD para seu crédito restante, e X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency para os limites aplicáveis à sua chave. Você pode vê-los com curl:

curl -i https://api.abliteratedapi.com/v1/chat/completions   -H "Authorization: Bearer $ABLITERATED_API_KEY"   -H "Content-Type: application/json"   -d '{"model":"uncensored","max_tokens":5,"messages":[{"role":"user","content":"Hi"}]}'

Os limites são os mesmos independentemente do cliente que você usa; a API é compatível com OpenAI, então qualquer SDK da OpenAI funciona assim que você altera a URL base para https://api.abliteratedapi.com/v1.

Qual limite você realmente atingirá?

Divida os dois números. Uma chave completa pode executar 8 requisições simultâneas e 300 por minuto, o que é uma média de 5 por segundo. Para atingir 300 por minuto com apenas 8 em andamento, cada chamada teria que ser concluída em 1,6 segundos em média (8 x 60 / 300). Respostas de um modelo de linguagem geralmente levam mais tempo do que isso quando têm mais de algumas frases, então em uma chave completa o limite de concorrência tende a ser o primeiro a ser atingido.

Considere um caso hipotético onde a chamada média dura 10 segundos. Oito vagas permitem 8 x 60 / 10 = 48 requisições por minuto, bem abaixo de 300. A mesma lógica para uma chave de teste: 2 vagas e 60 por minuto significam que chamadas com menos de 2 segundos são necessárias antes que o limite por minuto faça diferença. Essas durações são apenas uma ilustração, não uma medição. Meça suas próprias chamadas e insira o valor real.

O conselho prático: dimensione seu pool de workers para o limite de concorrência, não para o limite de requisições, e deixe o limite por minuto atuar como uma rede de segurança.

Como lidar com limites no código

Três hábitos cobrem quase todos os casos.

  1. Limite a concorrência você mesmo. Um semáforo dimensionado para o seu limite de concorrência significa que você raramente será recusado.
  2. Tente novamente com backoff exponencial e jitter. Aguarde 1 segundo, depois 2, depois 4, adicionando uma fração aleatória para que muitos workers não tentem novamente ao mesmo tempo. Pare após algumas tentativas.
  3. Não tente novamente cegamente. Uma requisição malformada ou uma chave inválida falhará sempre. Tente novamente apenas em limites de requisições e erros temporários do servidor.

O SDK Python oficial da OpenAI já tenta novamente em 429 e erros do servidor com backoff, e você o controla com max_retries. Combinado com um semáforo, um trabalho em lote se parece com isto:

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.abliteratedapi.com/v1",
    api_key=os.environ["ABLITERATED_API_KEY"],
    max_retries=5,
)
sem = asyncio.Semaphore(8)   # use 2 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one short fact about the number {n}." for n in range(40)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

Quarenta prompts passam, nunca mais de oito ao mesmo tempo. Se você construir seu próprio cliente, coloque as mesmas duas ideias nele: um limite de chamadas em andamento e um atraso de retry que cresce.

Limites de requisições não são a janela de contexto

As pessoas frequentemente confundem os dois, porque ambos produzem erros quando você pede demais. Um limite de requisições controla quantas requisições você faz. A janela de contexto controla o tamanho de uma única requisição.

Nesta API a janela de contexto é de 100.000 tokens, contando o prompt e a conclusão juntos. Se o seu prompt tiver 95.000 tokens, no máximo 5.000 ficam para a resposta. O parâmetro max_tokens é opcional: deixe-o de fora e a conclusão pode usar o que sobrar da janela. Definir isso ainda é um bom hábito quando você sabe que a resposta deve ser curta, porque tokens de saída custam $0,50 por 1M contra $0,15 por 1M para entrada. Um prompt completo de 95.000 tokens custa 95.000 x 0,15 / 1.000.000 = $0,01425 em entrada.

Um limite de requisições não encolhe a janela de contexto, e um contexto grande não usa limite de requisições extra. Cada chamada é uma requisição, independente do tamanho, desde que o corpo fique abaixo de 8 MB.

Streaming e limites de requisições

Com stream: true a resposta volta sobre eventos enviados pelo servidor, token por token, e o uso conta no final. Uma chamada em streaming ainda ocupa um slot de concorrência até que o stream termine, então um leitor lento que mantém conexões abertas segura slots por mais tempo do que você espera. Feche streams que você não precisa mais.

Erros comuns

  • Sem limite de workers. Um pool de threads com 50 workers contra um limite de 8 significa que a maioria das chamadas será recusada. Combine o pool com o limite de concorrência.
  • Retentativas imediatas. Retentar de imediato após uma recusa adiciona carga no pior momento. Espere, e espere cada vez mais.
  • Tratar todo erro como limite de requisições. Um timeout, uma chave inválida e um corpo grande demais precisam de correções diferentes. Registre o código de status e o cabeçalho X-Request-Id.
  • Compartilhar uma única chave para tudo. Um job noturno e um chat ao vivo na mesma chave competem pelos mesmos 8 slots. Use chaves separadas ou agende o job para horários de menor tráfego.
  • Ignorar streams lentos. Um cliente que para de ler mas mantém a conexão aberta ainda ocupa um slot.

Adicione um contador de chamadas recusadas aos seus logs. Se ele permanecer em zero, seu limite está correto. Se ele aumentar, reduza o tamanho do pool antes de adicionar retentativas.

Planejamento com base nos limites

Os limites de requisições e o orçamento estão conectados. Oito slots em plena capacidade podem consumir crédito rapidamente, então decida quanto você está disposto a gastar antes de iniciar um job. O preço é pagamento por uso, com crédito que nunca expira e sem cobrança para requisições falhas ou recusadas. Leia a página de preços para ver as tarifas e bônus de recarga, e o quickstart para os parâmetros de requisição. Para testar sua lógica de retentativa com segurança, obtenha uma chave de API e use o crédito de teste, que não precisa de cartão. Lembre-se apenas de que ele usa os limites menores de teste.

Perguntas e respostas

O que acontece quando excedo um limite de requisições?

O servidor recusa as requisições extras, tipicamente com HTTP 429, e seu código deve esperar e retentar. Reduza a velocidade ou diminua a concorrência até que os erros parem.

Quais são os limites desta API?

Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 requisições simultâneas e 60 por minuto.

Um limite de requisições é o mesmo que a janela de contexto?

Não. Um limite de requisições controla quantas requisições você pode enviar ao longo do tempo. A janela de contexto, 100.000 tokens aqui, controla o tamanho de uma única requisição e sua resposta.

Como vejo meus limites em uma resposta?

Leia os cabeçalhos de resposta X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. O cabeçalho X-Balance-USD mostra seu crédito restante, e X-Request-Id identifica uma chamada específica.

As requisições recusadas custam dinheiro?

Não. Requisições falhas ou recusadas não são cobradas nesta API.

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