A Batch API da Floopy executa jobs grandes de forma assíncrona e com custo menor. Ela é no formato OpenAI: aponte o baseURL do SDK da OpenAI para o gateway e use client.files + client.batches exatamente como faria contra a OpenAI — sem cliente novo, sem formatos novos para aprender.

Diferente de uma Batch API crua de provedor, cada requisição em lote é totalmente observável: cada linha aparece no seu painel de Requests marcada com o batch_id, conta para o seu uso, é tarifada e passa pelo mesmo pipeline de feedback/scoring de uma chamada ao vivo.

graph LR
    U[Upload JSONL<br/>POST /v1/files] --> C[Criar batch<br/>POST /v1/batches]
    C --> P[Batch API do provedor<br/>OpenAI / Anthropic]
    P --> R[Worker de reconciliação]
    R --> CH[(Logs por linha<br/>batch_id)]
    R --> M[Metering + uso]
    R --> O[Saída JSONL<br/>GET /v1/files/&#123;id&#125;/content]

1. Envie seu input como um arquivo JSONL (purpose: "batch"). Cada linha é uma requisição padrão de chat-completions com um custom_id.
2. Crie um batch referenciando o arquivo enviado.
3. Consulte o batch até ficar completed.
4. Baixe o arquivo de saída — JSONL no formato OpenAI, um resultado por custom_id.

Quando o batch termina, um worker em segundo plano reprocessa cada requisição para que ela fique indistinguível de uma chamada ao vivo no painel.

A superfície pública é sempre no formato OpenAI. O provedor é resolvido exatamente como no chat:

• o header floopy-provider (openai ou anthropic), ou
• a única chave de provedor configurada para a sua organização.

Para a Anthropic, o gateway traduz de forma transparente o seu input no formato OpenAI para Anthropic Message Batches na entrada, e os resultados de volta para o formato OpenAI na saída — então o mesmo código funciona com qualquer provedor apenas trocando o header.

Não há gate de plano nem flag separada: a Batch API está disponível sempre que o gateway estiver configurado para ela.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.floopy.ai/v1",
    api_key="SUA_CHAVE_FLOOPY",
)

# 1. Envie o arquivo de input (JSONL, uma requisição de chat por linha).
f = client.files.create(
    file=open("requests.jsonl", "rb"),
    purpose="batch",
)

# 2. Crie o batch.
batch = client.batches.create(
    input_file_id=f.id,
    endpoint="/v1/chat/completions",
    completion_window="24h",
)

# 3. Consulte até concluir e baixe a saída.
batch = client.batches.retrieve(batch.id)
if batch.status == "completed":
    out = client.files.content(batch.output_file_id)
    print(out.text)

# 1. Upload
curl https://api.floopy.ai/v1/files \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -F purpose=batch \
  -F file=@requests.jsonl

# 2. Criar (use floopy-provider para escolher o provedor)
curl https://api.floopy.ai/v1/batches \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -H "floopy-provider: anthropic" \
  -H "Content-Type: application/json" \
  -d '{"input_file_id":"file-abc","endpoint":"/v1/chat/completions","completion_window":"24h"}'

# 3. Consultar / baixar
curl https://api.floopy.ai/v1/batches/batch_abc \
  -H "Authorization: Bearer $FLOOPY_API_KEY"
curl https://api.floopy.ai/v1/files/file-out/content \
  -H "Authorization: Bearer $FLOOPY_API_KEY"

Cada linha do input é uma requisição padrão, com um custom_id que você usa para casar os resultados:

{"custom_id":"req-1","method":"POST","url":"/v1/chat/completions","body":{"model":"gpt-4o","messages":[{"role":"user","content":"Olá"}]}}

Os batches têm escopo por organização: você só enxerga os seus.

Requisições em lote não são um passthrough cego. Quando um batch conclui, cada linha é reconciliada no mesmo pipeline do tráfego ao vivo:

• Painel de Requests — uma linha por requisição, marcada com batch_id. Filtre a tela de Requests por batch para ver exatamente o que rodou, incluindo session id e os headers enviados no momento do envio.
• Uso & cobrança — cada requisição em lote conta para o uso mensal e é tarifada. O tráfego de batch conta para o limite mensal, mas não para os seus limites de requisições por minuto/segundo.
• Feedback & scoring — linhas de chat bem-sucedidas passam pelo pipeline de feedback (heurística sempre; o juiz LLM em taxa amostrada) quando o seu plano inclui o recurso de feedback, então os resultados de batch continuam melhorando o roteamento como as chamadas ao vivo.

O cache não é aplicado a requisições de batch, de forma intencional.