O processamento em lote é uma abordagem poderosa para lidar com grandes volumes de requisições de forma eficiente. Em vez de processar requisições uma de cada vez com respostas imediatas, o processamento em lote permite que você envie várias requisições juntas para processamento assíncrono. Esse padrão é particularmente útil quando:
A Message Batches API é a primeira implementação desse padrão pela Anthropic.
Este recurso não é elegível para Zero Data Retention (ZDR). Os dados são retidos de acordo com a política de retenção padrão do recurso.
A Message Batches API é uma forma poderosa e econômica de processar de forma assíncrona grandes volumes de requisições de Messages. Essa abordagem é adequada para tarefas que não exigem respostas imediatas, com a maioria dos lotes sendo concluída em menos de 1 hora, reduzindo custos em 50% e aumentando o throughput.
Você pode explorar a referência da API diretamente, além deste guia.
Quando você envia uma requisição para a Message Batches API:
Isso é especialmente útil para operações em massa que não exigem resultados imediatos, como:
max_tokens de pelo menos . () não é suportado dentro de um lote, já que uma entrada de cache efêmera gravada durante o processamento do lote provavelmente expiraria antes da execução da requisição subsequente.Todos os modelos ativos suportam a Message Batches API.
Quase qualquer requisição que você pode fazer à Messages API pode ser incluída em um lote. Isso inclui:
Como cada requisição no lote é processada de forma independente, você pode misturar diferentes tipos de requisições em um único lote.
Um pequeno número de parâmetros da Messages API não é suportado em requisições de lote. Incluir qualquer um destes retorna um erro de validação:
| Parâmetro | Motivo |
|---|---|
stream: true | Os resultados do lote retornam como um único arquivo, não como um stream. |
speed (Fast mode) | O Fast mode ajusta a latência síncrona, o que não se aplica ao processamento assíncrono em lote. |
store / previous_thread_event_id (Threads) | Threads têm estado; requisições de lote não. |
cache_hint / context_hint | Essas dicas de roteamento se aplicam apenas ao agendamento de requisições síncronas. |
max_tokens: 0 | Consulte Limitações de lote. |
research_preview_2026_02: "active" | O modo de pré-visualização de pesquisa não está disponível no caminho de lote. |
Como os lotes podem levar mais de 5 minutos para serem processados, considere usar a duração de cache de 1 hora com cache de prompt para obter melhores taxas de acerto de cache ao processar lotes com contexto compartilhado.
A Batches API oferece economia significativa de custos. Todo o uso é cobrado a 50% dos preços padrão da API.
| Modelo | Entrada em lote | Saída em lote |
|---|---|---|
| Claude Fable 5 | $5 / MTok | $25 / MTok |
| Claude Mythos 5 (disponibilidade limitada) | $5 / MTok | $25 / MTok |
| Claude Opus 4.8 | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.7 | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.6 | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.5 | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.1 (descontinuado) | $7.50 / MTok | $37.50 / MTok |
| Claude Opus 4 (descontinuado) | $7.50 / MTok |
Um Message Batch é composto por uma lista de requisições para criar uma Message. O formato de uma requisição individual é composto por:
custom_id único para identificar a requisição de Messages. Deve ter de 1 a 64 caracteres e conter apenas caracteres alfanuméricos, hífens e underscores (correspondendo a ^[a-zA-Z0-9_-]{1,64}$).params com os parâmetros padrão da Messages APIVocê pode criar um lote passando essa lista no parâmetro requests:
Neste exemplo, duas requisições separadas são agrupadas em lote para processamento assíncrono. Cada requisição tem um custom_id único e contém os parâmetros padrão que você usaria para uma chamada à Messages API.
Teste suas requisições de lote com a Messages API
A validação do objeto params para cada requisição de mensagem é realizada de forma assíncrona, e os erros de validação são retornados quando o processamento de todo o lote termina. Você pode garantir que está construindo sua entrada corretamente verificando primeiro o formato da sua requisição com a Messages API.
Quando um lote é criado pela primeira vez, a resposta terá um status de processamento in_progress.
{
"id": "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d",
"type": "message_batch",
"processing_status": "in_progress",
"request_counts": {
"processing": 2,
"succeeded": 0,
"errored": 0,
"canceled": 0,
"expired": 0
},
"ended_at": null,
"created_at": "2024-09-24T18:37:24.100435Z",
"expires_at": "2024-09-25T18:37:24.100435Z",
"cancel_initiated_at": null,
"results_url": null
}O campo processing_status do Message Batch indica o estágio de processamento em que o lote está. Ele começa como in_progress e depois é atualizado para ended quando todas as requisições no lote terminaram de ser processadas e os resultados estão prontos. Você pode monitorar o estado do seu lote visitando o Console ou usando o endpoint de recuperação.
Para fazer polling de um Message Batch, você precisará do seu id, que é fornecido na resposta ao criar um lote ou ao listar lotes. Você pode implementar um loop de polling que verifica o status do lote periodicamente até que o processamento termine:
Você pode listar todos os Message Batches no seu Workspace usando o endpoint de listagem. A API suporta paginação, buscando automaticamente páginas adicionais conforme necessário:
Quando o processamento do lote termina, cada requisição de Messages no lote tem um resultado. Existem 4 tipos de resultado:
| Tipo de resultado | Descrição |
|---|---|
succeeded | A requisição foi bem-sucedida. Inclui o resultado da mensagem. |
errored | A requisição encontrou um erro e uma mensagem não foi criada. Possíveis erros incluem requisições inválidas e erros internos do servidor. Você não será cobrado por essas requisições. |
canceled | O usuário cancelou o lote antes que essa requisição pudesse ser enviada ao modelo. Você não será cobrado por essas requisições. |
expired | O lote atingiu sua expiração de 24 horas antes que essa requisição pudesse ser enviada ao modelo. Você não será cobrado por essas requisições. |
Você verá uma visão geral dos seus resultados com o request_counts do lote, que mostra quantas requisições atingiram cada um desses quatro estados.
Os resultados do lote estão disponíveis para download na propriedade results_url do Message Batch e, se a permissão da organização permitir, no Console. Devido ao tamanho potencialmente grande dos resultados, é recomendado fazer streaming dos resultados em vez de baixá-los todos de uma vez.
Os resultados estão no formato .jsonl, onde cada linha é um objeto JSON válido representando o resultado de uma única requisição no Message Batch. Para cada resultado transmitido via streaming, você pode fazer algo diferente dependendo do seu custom_id e tipo de resultado. Aqui está um exemplo de conjunto de resultados:
{"custom_id":"my-second-request","result":{"type":"succeeded","message":{"id":"msg_014VwiXbi91y3JMjcpyGBHX5","type":"message","role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"Hello again! It's nice to see you. How can I assist you today? Is there anything specific you'd like to chat about or any questions you have?"}],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":11,"output_tokens":36}}}}
{"custom_id":"my-first-request","result":{"type":"succeeded","message":{"id":"msg_01FqfsLoHwgeFbguDgpz48m7","type":"message","role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"Hello! How can I assist you today? Feel free to ask me any questions or let me know if there's anything you'd like to chat about."}],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":34}}}}Se o seu resultado tiver um erro, seu result.error será definido com o formato de erro padrão.
Os resultados do lote podem não corresponder à ordem de entrada
Os resultados do lote podem ser retornados em qualquer ordem e podem não corresponder à ordem das requisições quando o lote foi criado. No exemplo acima, o resultado da segunda requisição do lote é retornado antes da primeira. Para corresponder corretamente os resultados com suas respectivas requisições, sempre use o campo custom_id.
Você pode cancelar um Message Batch que está sendo processado no momento usando o endpoint de cancelamento. Imediatamente após o cancelamento, o processing_status de um lote será canceling. Você pode usar a mesma técnica de polling descrita acima para aguardar até que o cancelamento seja finalizado. Lotes cancelados terminam com um status ended e podem conter resultados parciais para requisições que foram processadas antes do cancelamento.
A resposta mostrará o lote em um estado canceling:
{
"id": "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
"type": "message_batch",
"processing_status": "canceling",
"request_counts": {
"processing": 2,
"succeeded": 0,
"errored": 0,
"canceled": 0,
"expired": 0
},
"ended_at": null,
"created_at": "2024-09-24T18:37:24.100435Z",
"expires_at": "2024-09-25T18:37:24.100435Z",
"cancel_initiated_at": "2024-09-24T18:39:03.114875Z",
"results_url": null
}A Message Batches API suporta cache de prompt, permitindo que você potencialmente reduza custos e tempo de processamento para requisições em lote. Os descontos de preço do cache de prompt e do Message Batches podem ser acumulados, proporcionando economia de custos ainda maior quando ambos os recursos são usados juntos. No entanto, como as requisições em lote são processadas de forma assíncrona e concorrente, os acertos de cache são fornecidos com base no melhor esforço. Os usuários normalmente experimentam taxas de acerto de cache variando de 30% a 98%, dependendo de seus padrões de tráfego.
Para maximizar a probabilidade de acertos de cache em suas requisições de lote:
cache_control idênticos em cada requisição de Message dentro do seu loteExemplo de implementação de cache de prompt em um lote:
Neste exemplo, ambas as requisições no lote incluem mensagens de sistema idênticas e o texto completo de Orgulho e Preconceito marcado com cache_control para aumentar a probabilidade de acertos de cache.
Todas as ferramentas de servidor (busca na web, busca de conteúdo web, execução de código, conectores MCP, advisor e busca de ferramentas) funcionam em requisições de lote. O worker de lote executa o mesmo loop agêntico do lado do servidor que a Messages API síncrona.
Como não há conexão aberta a ser mantida, o loop de lote executa mais iterações por turno do que uma requisição síncrona antes de retornar stop_reason: "pause_turn". Se um resultado de lote retornar com pause_turn, o turno não foi concluído; você pode continuá-lo enviando o conteúdo pausado do assistente em uma requisição subsequente (em lote ou síncrona) exatamente como mostrado no padrão de continuação pause_turn.
O worker de lote adicionalmente limita web_search por organização para que o processamento em lote altamente concorrente não esgote o limite de taxa de busca na web da sua organização. O lote tenta novamente as requisições limitadas automaticamente; você não precisa lidar com isso por conta própria, mas lotes muito grandes de busca na web podem levar mais tempo para serem concluídos.
O cabeçalho beta output-300k-2026-03-24 aumenta o limite de max_tokens para 300.000 em requisições de lote usando Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6 ou Claude Sonnet 4.6. Inclua o cabeçalho para gerar saídas muito mais longas do que o limite padrão (64k a 128k dependendo do modelo) em um único turno.
A saída estendida está disponível apenas na Message Batches API, não na Messages API síncrona. Ela é suportada na Claude API e na Claude Platform na AWS, e atualmente não está disponível no Amazon Bedrock, Vertex AI ou Microsoft Foundry.
Use a saída estendida para geração de conteúdo longo, como rascunhos do tamanho de livros e documentação técnica, extração exaustiva de dados estruturados, grandes estruturas de geração de código e longas cadeias de raciocínio.
Uma única geração de 300k tokens pode levar mais de uma hora para ser concluída, então planeje seus envios de lote tendo em mente a janela de processamento de 24 horas. Aplica-se o preço padrão de lote (50% dos preços padrão da API).
Para aproveitar ao máximo a Batches API:
custom_id significativos para corresponder facilmente resultados com requisições, já que a ordem não é garantida.Se estiver experimentando comportamento inesperado:
request_too_large.custom_id único.created_at do lote (não o horário ended_at do processamento). Se mais de 29 dias se passaram, os resultados não estarão mais visíveis.Observe que a falha de uma requisição em um lote não afeta o processamento de outras requisições.
Isolamento de Workspace: os lotes são isolados dentro do Workspace em que são criados. Eles só podem ser acessados por chaves de API associadas a esse Workspace, ou por usuários com permissão para visualizar lotes do Workspace no Console.
Disponibilidade de resultados: os resultados do lote ficam disponíveis por 29 dias após a criação do lote, permitindo tempo suficiente para recuperação e processamento.
O processamento em lote armazena dados de requisição e resposta por até 29 dias após a criação do lote. Você pode excluir um message batch a qualquer momento após o processamento usando o endpoint DELETE /v1/messages/batches/{batch_id}. Para excluir um lote em andamento, cancele-o primeiro. O processamento assíncrono requer armazenamento do lado do servidor tanto de entradas quanto de saídas até a conclusão do lote e a recuperação dos resultados.
Para elegibilidade de ZDR em todos os recursos, consulte API e retenção de dados.
Was this page helpful?
1max_tokens: 0| $37.50 / MTok |
| Claude Sonnet 4.6 | $1.50 / MTok | $7.50 / MTok |
| Claude Sonnet 4.5 | $1.50 / MTok | $7.50 / MTok |
| Claude Sonnet 4 (descontinuado) | $1.50 / MTok | $7.50 / MTok |
| Claude Haiku 4.5 | $0.50 / MTok | $2.50 / MTok |
| Claude Haiku 3.5 (desativado, exceto no Bedrock e Vertex AI) | $0.40 / MTok | $2 / MTok |
from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request
client = anthropic.Anthropic()
message_batch = client.messages.batches.create(
requests=[
Request(
custom_id="my-first-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-4-8",
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Hello, world",
}
],
),
),
Request(
custom_id="my-second-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-4-8",
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Hi again, friend",
}
],
),
),
]
)
print(message_batch)import time
client = anthropic.Anthropic()
MESSAGE_BATCH_ID = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"
message_batch = None
while True:
message_batch = client.messages.batches.retrieve(MESSAGE_BATCH_ID)
if message_batch.processing_status == "ended":
break
print(f"Batch {MESSAGE_BATCH_ID} is still processing...")
time.sleep(60)
print(message_batch)client = anthropic.Anthropic()
# Busca automaticamente mais páginas conforme necessário.
for message_batch in client.messages.batches.list(limit=20):
print(message_batch)client = anthropic.Anthropic()
# Faz streaming do arquivo de resultados em blocos eficientes em memória, processando um de cada vez
for result in client.messages.batches.results(
"msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d",
):
match result.result.type:
case "succeeded":
print(f"Success! {result.custom_id}")
case "errored":
if result.result.error.error.type == "invalid_request_error":
# O corpo da requisição deve ser corrigido antes de reenviar a requisição
print(f"Validation error {result.custom_id}")
else:
# A requisição pode ser repetida diretamente
print(f"Server error {result.custom_id}")
case "expired":
print(f"Request expired {result.custom_id}")client = anthropic.Anthropic()
MESSAGE_BATCH_ID = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"
message_batch = client.messages.batches.cancel(
MESSAGE_BATCH_ID,
)
print(message_batch)from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request
client = anthropic.Anthropic()
message_batch = client.messages.batches.create(
requests=[
Request(
custom_id="my-first-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-4-8",
max_tokens=1024,
system=[
{
"type": "text",
"text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
},
{
"type": "text",
"text": "<the entire contents of Pride and Prejudice>",
"cache_control": {"type": "ephemeral"},
},
],
messages=[
{
"role": "user",
"content": "Analyze the major themes in Pride and Prejudice.",
}
],
),
),
Request(
custom_id="my-second-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-4-8",
max_tokens=1024,
system=[
{
"type": "text",
"text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
},
{
"type": "text",
"text": "<the entire contents of Pride and Prejudice>",
"cache_control": {"type": "ephemeral"},
},
],
messages=[
{
"role": "user",
"content": "Write a summary of Pride and Prejudice.",
}
],
),
),
]
)from anthropic.types.beta.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.beta.messages.batch_create_params import Request
client = anthropic.Anthropic()
message_batch = client.beta.messages.batches.create(
betas=["output-300k-2026-03-24"],
requests=[
Request(
custom_id="long-form-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-4-8",
max_tokens=300_000,
messages=[
{
"role": "user",
"content": "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices.",
}
],
),
),
],
)
print(message_batch)