> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Inferência em lote

export const BatchApiModels = () => {
  if (typeof document === "undefined") {
    return null;
  } else {
    let attempts = 0;
    const maxAttempts = 50;
    const INIT_DISPLAY_COUNT = 3;
    const interval = setInterval(() => {
      const clientComponent = document.getElementById("batch-api-models");
      if (clientComponent && window.novitaRemoteData.llmModels.status === 'loaded') {
        const modelList = window.novitaRemoteData.llmModels.data.filter(model => {
          return (model.endpoints || []).includes('batch-api');
        });
        let displayModels = modelList.slice(0, INIT_DISPLAY_COUNT).map(model => {
          return `<li><span class="model-id-item">${model.id}</span></li>`;
        }).join('');
        let showMoreButton = '';
        if (modelList.length > INIT_DISPLAY_COUNT) {
          showMoreButton = `<button id="show-more-batch-api-model-btn" style="margin-left: 32px; color: rgb(40 116 255)">View More</button>`;
        }
        clientComponent.innerHTML = `
          <ul>${displayModels}</ul>
          ${showMoreButton}
        `;
        document.getElementById('show-more-batch-api-model-btn')?.addEventListener('click', () => {
          clientComponent.innerHTML = `
            <ul>${modelList.map(model => {
            return `<li><span class="model-id-item">${model.id}</span></li>`;
          }).join('')}</ul>
          `;
        });
        clearInterval(interval);
      }
      attempts++;
      if (attempts >= maxAttempts) {
        clearInterval(interval);
      }
    }, 200);
    return <div id="batch-api-models"></div>;
  }
};

A Batch API para Large Language Models permite o processamento assíncrono de inúmeras solicitações de inferência e é totalmente compatível com o padrão da OpenAI API.

A Batch API é uma solução econômica quando resultados de inferência imediatos não são necessários. Ela oferece limites de taxa mais altos do que chamadas online, garantindo que os resultados sejam entregues dentro de um prazo razoável de 24 horas.

Esta API é ideal para:

* Realizar avaliações e análise de dados.
* Classificar conjuntos de dados extensos.
* Gerar resumos de documentos em modo offline.

Modelos compatíveis:

<BatchApiModels />

## Início rápido

### 1. Preparar arquivos de lote

A Batch API usa arquivos no formato .jsonl como entrada, com cada linha representando os detalhes de uma solicitação de inferência da API. Os endpoints disponíveis incluem `/v1/chat/completions` e `/v1/completions`.

<Warning>
  Defina o parâmetro `endpoint` como `/v1/chat/completions` ou `/v1/completions` para compatibilidade com a OpenAI API.
</Warning>

Cada solicitação deve incluir um `custom_id` exclusivo para localizar os resultados de inferência no arquivo de saída após a conclusão do lote. Os parâmetros no campo `body` de cada linha são enviados como parâmetros reais da solicitação de inferência para o endpoint.

<Warning>
  Todas as solicitações em um único arquivo JSONL de lote devem direcionar para o mesmo modelo. Não misture solicitações para modelos diferentes em um lote.
</Warning>

Abaixo está um exemplo de arquivo de entrada contendo 2 solicitações:

```JSON theme={"system"}
{"custom_id": "request-1", "body": {"model": "deepseek/deepseek-v3-0324", "messages": [{"role": "user", "content": "Hello, world!"}], "max_tokens": 400}}
{"custom_id": "request-2", "body": {"model": "deepseek/deepseek-v3-0324", "messages": [{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Hello world!"}],"max_tokens": 1000}}
```

### 2. Fazer upload do arquivo de entrada do lote

Faça upload do arquivo de entrada do lote para garantir que ele possa ser referenciado com precisão ao criar um lote. Use a Files API para fazer upload do seu arquivo .jsonl e defina o purpose como `batch`. Observe que o arquivo será retido por 15 dias.

<Tip>
  Para saber como obter a chave de API, consulte [Gerenciamento de chaves de API](/docs/pt-BR/api-reference/basic-authentication).
</Tip>

Exemplo de código

**Python**

```python theme={"system"}
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai/v1",
    api_key="<Your API Key>",
)

batch_input_file = client.files.create(
    file=open("batch_input.jsonl", "rb"),
    purpose="batch",
)

print(batch_input_file)
```

**Curl**

```bash theme={"system"}
export API_KEY="<Your API Key>"

curl --request POST \
  --url https://api.novita.ai/openai/v1/files \
  --header 'Authorization: Bearer ${API_KEY}' \
  --form 'file=@"/your/batch_input.jsonl"' \
  --form 'purpose="batch"'
```

Resposta de exemplo após o upload bem-sucedido do arquivo:

```
{
    "id": "file_d2co***as73c0cjd0",
    "object": "file",
    "bytes": 238,
    "filename": "batch_input.jsonl",
    "created_at": 1754894162,
    "purpose": "batch",
    "metadata": {
        "total_requests": 2
    }
}
```

### 3. Criar um lote

Depois que o arquivo de entrada for carregado com sucesso, você poderá iniciar um lote usando o ID do objeto File carregado. A janela de conclusão é fixa em `24h` e atualmente não é ajustável.

Exemplo de código

**Python**

```python theme={"system"}
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai/v1",
    api_key="<Your API Key>",
)

batch = client.batches.create(
  input_file_id="file_d2cor0es1cas73c0cj60",
  endpoint="/v1/chat/completions",
  completion_window="24h"
)
print(batch)
```

**Curl**

```bash theme={"system"}
export API_KEY="<Your API Key>"

curl --request POST \
  --url https://api.novita.ai/openai/v1/batches \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer ${API_KEY}' \
  --data '{
      "input_file_id": "file_d2co***as73c0cjd0",
      "endpoint": "/v1/chat/completions",
      "completion_window": "24h"
  }'
```

Esta solicitação retornará um objeto Batch que inclui metadados sobre seu lote, conforme ilustrado no exemplo abaixo:

```JSON theme={"system"}
{
    "id": "batch_d2cq***73a68lu0",
    "object": "batch",
    "endpoint": "/v1/chat/completions",
    "input_file_id": "file_d2co***as73c0cjd0",
    "output_file_id": "",
    "error_file_id": "",
    "completion_window": "24h",
    "in_progress_at": null,
    "expires_at": null,
    "finalizing_at": null,
    "completed_at": null,
    "failed_at": null,
    "expired_at": null,
    "cancelling_at": null,
    "cancelled_at": null,
    "status": "validating",
    "errors": "",
    "version": 0,
    "created_at": "2025-08-11T16:31:52.949816948+08:00",
    "updated_at": null,
    "created_by": "8f242aa1-f725-4a67-8***9-cb68025e0976",
    "created_by_key_id": "key_cc19f96c***e7390644a37da21",
    "remark": "",
    "total": 0,
    "completed": 0,
    "failed": 0,
    "metadata": null,
    "request_counts": {
        "total": 0,
        "completed": 0,
        "failed": 0
    }
}
```

### 4. Verificar o status de um lote

Você pode verificar o status de um lote a qualquer momento para receber as informações mais recentes do lote.

Os valores de enumeração de status do objeto Batch são os seguintes:

<table class="table table-big">
  <thead>
    <tr>
      <th>Status</th>
      <th>Descrição</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>VALIDATING</td>
      <td>O arquivo de entrada está sendo validado antes que o lote possa começar</td>
    </tr>

    <tr>
      <td>PROGRESS</td>
      <td>O lote está em andamento</td>
    </tr>

    <tr>
      <td>COMPLETED</td>
      <td>O processamento do lote foi concluído com sucesso</td>
    </tr>

    <tr>
      <td>FAILED</td>
      <td>O processamento do lote falhou</td>
    </tr>

    <tr>
      <td>EXPIRED</td>
      <td>O lote excedeu o prazo</td>
    </tr>

    <tr>
      <td>CANCELLING</td>
      <td>O lote está sendo cancelado</td>
    </tr>

    <tr>
      <td>CANCELLED</td>
      <td>O lote foi cancelado</td>
    </tr>
  </tbody>
</table>

Exemplo de código

**Python**

```python theme={"system"}
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai/v1",
    api_key="<Your API Key>",
)
batch = client.batches.retrieve("batch_d2cq***73a68lu0")
print(batch)
```

**Curl**

```bash theme={"system"}
export API_KEY="<Your API Key>"

curl --request GET \
  --url https://api.novita.ai/openai/v1/batches/{batch_id} \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer ${API_KEY}'
```

### 5. Recuperar os resultados

Depois que a inferência em lote for concluída, você poderá baixar o arquivo de saída de resultados usando o campo `output_file_id` do objeto Batch.

O arquivo de saída de resultados será excluído 30 dias após a conclusão da inferência em lote, portanto, recupere-o prontamente por meio da interface.

Exemplo de código

**Python**

```python theme={"system"}
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai/v1",
    api_key="<Your API Key>",
)

content = client.files.content("example-250811-1")
print(content.read())
```

**Curl**

```bash theme={"system"}
export API_KEY="<Your API Key>"

curl --request GET \
  --url https://api.novita.ai/openai/v1/files/{file_id}/content \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer ${API_KEY}'
```

A resposta retorna o conteúdo bruto do arquivo. Para arquivos de saída em lote, cada linha contém uma resposta como esta:

```json theme={"system"}
{
  "custom_id": "request-2589",
  "error": null,
  "id": "batch_req_task_d2c",
  "response": {
    "body": {
      "id": "29e1432c-edfb-44a4-b531-c23c600abfae",
      "object": "chat.completion",
      "created": 1754902266,
      "model": "deepseek-test",
      "choices": [
        {
          "index": 0,
          "message": {
            "role": "assistant",
            "content": "Hello! 👋 How can I assist you today? 😊"
          },
          "finish_reason": "stop"
        }
      ],
      "usage": {
        "prompt_tokens": 5,
        "completion_tokens": 13,
        "total_tokens": 18
      }
    },
    "request_id": "request-2589",
    "status_code": 200
  }
}
```

## Instruções

### Limitações

1. Cada lote pode conter até 50.000 solicitações.<br />
2. O tamanho máximo do arquivo de entrada por lote é de 100 MB.

### Tratamento de erros

Erros encontrados durante o processamento em lote são registrados em um arquivo de erro separado, acessível por meio do campo error\_file\_id. Códigos de erro comuns incluem:

<table class="table table-big">
  <thead>
    <tr>
      <th>Código de erro</th>
      <th>Descrição</th>
      <th>Solução</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>400</td>
      <td>Formato de solicitação inválido</td>
      <td>Verifique a sintaxe JSONL e os campos obrigatórios</td>
    </tr>

    <tr>
      <td>401</td>
      <td>Falha na autenticação</td>
      <td>Verifique a chave de API</td>
    </tr>

    <tr>
      <td>404</td>
      <td>Lote não encontrado</td>
      <td>Verifique o ID do lote</td>
    </tr>

    <tr>
      <td>429</td>
      <td>Limite de taxa excedido</td>
      <td>Reduza a frequência das solicitações</td>
    </tr>

    <tr>
      <td>500</td>
      <td>Erro do servidor</td>
      <td>Entre em contato conosco</td>
    </tr>
  </tbody>
</table>

### Expiração de lotes

Lotes não concluídos em 24 horas passarão para o estado EXPIRED. Solicitações não finalizadas serão canceladas, enquanto solicitações concluídas serão fornecidas por meio de um arquivo de saída. Você paga apenas pelos tokens consumidos pelas solicitações concluídas. O lote faz todos os esforços para ser concluído em 24 horas.

## Todas as APIs de lote

1. [Criar lote](/docs/pt-BR/api-reference/model-apis-llm-create-batch)
2. [Recuperar lote](/docs/pt-BR/api-reference/model-apis-llm-retrieve-batch)
3. [Cancelar lote](/docs/pt-BR/api-reference/model-apis-llm-cancel-batch)
4. [Listar lotes](/docs/pt-BR/api-reference/model-apis-llm-list-batches)
5. [Fazer upload de arquivo](/docs/pt-BR/api-reference/model-apis-llm-upload-batch-input-file)
6. [Listar arquivos](/docs/pt-BR/api-reference/model-apis-llm-list-files)
7. [Recuperar arquivo](/docs/pt-BR/api-reference/model-apis-llm-query-file)
8. [Excluir arquivo](/docs/pt-BR/api-reference/model-apis-llm-delete-file)
9. [Recuperar conteúdo do arquivo](/docs/pt-BR/api-reference/model-apis-llm-retrieve-file-content)
