Elaborazione batch
Elabora grandi volumi di richieste Messages in modo asincrono con la Message Batches API, riducendo i costi del 50 percento e aumentando il throughput.
L’elaborazione in batch è un approccio potente per gestire grandi volumi di richieste in modo efficiente. Invece di elaborare le richieste una alla volta con risposte immediate, l’elaborazione in batch ti consente di inviare più richieste insieme per un’elaborazione asincrona. Questo modello è particolarmente utile quando:
- Devi elaborare grandi volumi di dati
- Non sono richieste risposte immediate
- Vuoi ottimizzare l’efficienza dei costi
- Stai eseguendo valutazioni o analisi su larga scala
La Message Batches API implementa questo modello.
Message Batches API
La Message Batches API è un modo potente ed economico per elaborare in modo asincrono grandi volumi di richieste MessagesAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro). Questo approccio è adatto a compiti che non richiedono risposte immediate, con la maggior parte dei batch che si completa in meno di 1 ora, riducendo i costi del 50 percento e aumentando il “throughput” (capacità di elaborazione).
Oltre a questa guida, puoi esplorare direttamente il riferimento APIAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro).
Come funziona la Message Batches API
Quando invii una richiesta alla Message Batches API:
- Il sistema crea un nuovo batch di messaggi con le richieste Messages fornite.
- Il batch viene quindi elaborato in modo asincrono, con ogni richiesta gestita in modo indipendente.
- Puoi interrogare lo stato del batch e recuperare i risultati quando l’elaborazione è terminata per tutte le richieste.
Questo è particolarmente utile per operazioni in blocco che non richiedono risultati immediati, come:
- Valutazioni su larga scala: elabora migliaia di casi di test in modo efficiente.
- Moderazione dei contenuti: analizza grandi volumi di contenuti generati dagli utenti in modo asincrono.
- Analisi dei dati: genera approfondimenti o riepiloghi per grandi dataset.
- Generazione di contenuti in blocco: crea grandi quantità di testo per vari scopi (ad esempio, descrizioni di prodotti, riepiloghi di articoli).
Limitazioni dei batch
- Un batch di messaggi è limitato a 100.000 richieste Message o a 256 MB di dimensione, a seconda di quale limite venga raggiunto per primo.
- Il sistema elabora ogni batch il più velocemente possibile, con la maggior parte dei batch che si completa entro 1 ora. Puoi accedere ai risultati del batch quando tutti i messaggi sono stati completati o dopo 24 ore, a seconda di quale evento si verifichi per primo. I batch scadono se l’elaborazione non si completa entro 24 ore.
- I risultati del batch sono disponibili per 29 giorni dopo la creazione. Dopo tale periodo, puoi ancora visualizzare il batch, ma i suoi risultati non sono più disponibili per il download.
- I batch sono circoscritti a un Workspace nella Claude Console. Puoi visualizzare tutti i batch (e i relativi risultati) creati all’interno del Workspace in cui viene eseguita la tua richiesta.
- I limiti di velocità si applicano sia alle richieste HTTP della Batches API sia al numero di richieste all’interno di un batch in attesa di essere elaborate. Consulta Limiti di velocità della Message Batches API. Inoltre, l’elaborazione potrebbe essere rallentata in base alla domanda attuale e al volume delle tue richieste. In tal caso, potresti vedere più richieste scadere dopo 24 ore.
- A causa dell’elevato throughput e dell’elaborazione concorrente, i batch potrebbero superare leggermente il limite di spesa configurato nella Claude Console per il tuo Workspace.
- Ogni richiesta in batch deve avere
max_tokensAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) pari ad almeno1.max_tokens: 0(pre-riscaldamento della cache) non è supportato all’interno di un batch, perché una voce di cache effimera scritta durante l’elaborazione del batch scadrebbe probabilmente prima dell’esecuzione della richiesta successiva.
Modelli supportati
Tutti i modelli attivi supportano la Message Batches API.
Cosa può essere inserito in un batch
Quasi tutte le richieste che puoi effettuare alla Messages API possono essere incluse in un batch. Ciò include:
- Visione
- Uso degli strumenti, inclusi tutti gli strumenti server (ricerca web, recupero web, esecuzione di codice, connettori MCP, advisor e ricerca di strumenti)
- Messaggi di sistema
- Conversazioni a più turni
- Ragionamento esteso
- La maggior parte delle funzionalità beta
Poiché ogni richiesta nel batch viene elaborata in modo indipendente, puoi combinare diversi tipi di richieste all’interno di un singolo batch.
Un piccolo numero di parametri della Messages API non è supportato nelle richieste in batch. Includere uno qualsiasi di questi restituisce un errore di validazione:
| Parametro | Motivo |
|---|---|
stream: true | I risultati del batch vengono restituiti come un singolo file, non come uno stream. |
speed (Modalità veloce) | La modalità veloce ottimizza la latenza sincrona, che non si applica all’elaborazione asincrona in batch. |
fallbacks (Fallback lato server) | Il fallback lato server non si applica ai batch. Per ritentare le richieste rifiutate, consulta Rifiuti nei Message Batches. |
max_tokens: 0 | Consulta Limitazioni dei batch. |
Prezzi
La Batches API offre notevoli risparmi sui costi. Tutto l’utilizzo viene addebitato al 50 percento dei prezzi standard dell’API.
| Modello | Token batch | |
|---|---|---|
| Nome | Input | Output |
Claude Fable 5.2For demanding reasoning and long-horizon agentic work | 4 USD / | 20 USD / MTok |
Claude Opus 5.5For long-running agentic coding and knowledge work | 2 USD / MTok | 10 USD / MTok |
Claude Sonnet 5.5The best combination of speed and intelligence | 1 USD / MTok | 5 USD / MTok |
Claude Haiku 5.5For high-volume, latency-sensitive tasks such as classification, extraction, and routing | 0,05 USD / MTokper prompt fino a 100.000 token | 0,25 USD / MTok |
0,25 USD / MTokper prompt oltre 100.000 token | 1,25 USD / MTok | |
4 USD / MTok | 20 USD / MTok | |
5 USD / MTok | 25 USD / MTok | |
5 USD / MTok | 25 USD / MTok | |
5 USD / MTok | 25 USD / MTok | |
5 USD / MTok | 25 USD / MTok | |
2,50 USD / MTok | 12,50 USD / MTok | |
2,50 USD / MTok | 12,50 USD / MTok | |
2,50 USD / MTok | 12,50 USD / MTok | |
2,50 USD / MTok | 12,50 USD / MTok | |
2,50 USD / MTok | 12,50 USD / MTok | |
Claude Opus 4.1 | 7,50 USD / MTok | 37,50 USD / MTok |
Claude Opus 4 | 7,50 USD / MTok | 37,50 USD / MTok |
1 USD / MTok | 5 USD / MTok | |
1,50 USD / MTok | 7,50 USD / MTok | |
1,50 USD / MTok | 7,50 USD / MTok | |
Claude Sonnet 4 | 1,50 USD / MTok | 7,50 USD / MTok |
0,50 USD / MTok | 2,50 USD / MTok | |
Come usare la Message Batches API
Prepara e crea il tuo batch
Un batch di messaggi è composto da un elenco di richieste per creare un Message. La struttura di una singola richiesta comprende:
- Un
custom_idAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) univoco per identificare la richiesta Messages. Deve contenere da 1 a 64 caratteri e solo caratteri alfanumerici, trattini e underscore (corrispondenti a^[a-zA-Z0-9_-]{1,64}$). - Un oggetto
paramsAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) con i parametri standard della Messages APIAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro)
Puoi creare un batchAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) passando questo elenco nel parametro requests:
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-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Hello, world",
}
],
),
),
Request(
custom_id="my-second-request",
params=MessageCreateParamsNonStreaming(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Hi again, friend",
}
],
),
),
]
)
print(message_batch)In questo esempio, due richieste separate vengono raggruppate in un batch per l’elaborazione asincrona. Ogni richiesta ha un custom_id univoco e contiene i parametri standard che useresti per una chiamata alla Messages API.
Quando un batch viene creato per la prima volta, la risposta ha uno stato di elaborazione 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
}Monitorare il tuo batch
Il campo processing_statusAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) del batch di messaggi indica la fase di elaborazione in cui si trova il batch. Inizia come in_progress, poi si aggiorna a ended una volta che tutte le richieste nel batch hanno terminato l’elaborazione e i risultati sono pronti. Puoi monitorare lo stato del tuo batch visitando la Console o usando l’endpoint di recupero.
Polling per il completamento del batch di messaggi
Per effettuare il “polling” (interrogazione periodica) di un batch di messaggi, ti servirà il suo id, fornito nella risposta alla creazione di un batch o elencando i batch. Puoi implementare un ciclo di polling che controlla periodicamente lo stato del batch finché l’elaborazione non è terminata:
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)Elencare tutti i batch di messaggi
Puoi elencare tutti i batch di messaggi nel tuo Workspace usando l’endpoint di elencoAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro). I risultati sono paginati. L’SDK recupera pagine aggiuntive secondo necessità:
client = anthropic.Anthropic()
# Recupera automaticamente altre pagine quando necessario.
for message_batch in client.messages.batches.list(limit=20):
print(message_batch)Recuperare i risultati del batch
Una volta terminata l’elaborazione del batch, ogni richiesta Messages nel batch ha un risultato. Esistono quattro tipi di risultato:
| Tipo di risultato | Descrizione |
|---|---|
succeeded | La richiesta è andata a buon fine. Include il risultato del messaggio. |
errored | La richiesta ha riscontrato un errore e non è stato creato alcun messaggio. Gli errori possibili includono richieste non valide ed errori interni del server. Non ti vengono addebitate queste richieste. |
canceled | L’utente ha annullato il batch prima che questa richiesta potesse essere inviata al modello. Non ti vengono addebitate queste richieste. |
expired | Il batch ha raggiunto la scadenza di 24 ore prima che questa richiesta potesse essere inviata al modello. Non ti vengono addebitate queste richieste. |
L’oggetto request_counts del batch conta le richieste ancora in elaborazione e le richieste per ciascun tipo di risultato.
I risultati del batch sono disponibili per il download nella proprietà results_urlAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) del batch di messaggi e, se i permessi della tua organizzazione lo consentono, nella Console. Poiché i risultati possono essere di grandi dimensioni, ricevi i risultati in streamingAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro) anziché scaricarli tutti in una volta.
client = anthropic.Anthropic()
# Esegui lo streaming del file dei risultati in blocchi efficienti in memoria, elaborandone uno alla volta
for result in client.messages.batches.results(
"msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d",
):
outcome = result.result
match outcome.type:
case "succeeded":
print(f"Success! {result.custom_id}")
case "errored":
if outcome.error.error.type == "invalid_request_error":
# Il corpo della richiesta deve essere corretto prima di inviare di nuovo la richiesta
print(f"Validation error {result.custom_id}")
else:
# La richiesta può essere ritentata direttamente
print(f"Server error {result.custom_id}")
case "expired":
print(f"Request expired {result.custom_id}")I risultati sono in formato .jsonl, dove ogni riga è un oggetto JSON valido che rappresenta il risultato di una singola richiesta nel batch di messaggi. Per ogni risultato ricevuto in streaming, puoi eseguire un’azione diversa a seconda del suo custom_id e del tipo di risultato. Ecco un esempio di insieme di risultati:
{"custom_id":"my-second-request","result":{"type":"succeeded","message":{"id":"msg_014VwiXbi91y3JMjcpyGBHX5","type":"message","role":"assistant","model":"claude-opus-5-5","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-5-5","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 il tuo risultato contiene un errore, il suo result.error sarà impostato sulla struttura di errore standard.
I risultati del batch usano la versione dell’API della richiesta che ha creato il batch.
Annullare un batch di messaggi
Puoi annullare un batch di messaggi attualmente in elaborazione usando l’endpoint di annullamentoAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro). Subito dopo l’annullamento, il processing_status di un batch è canceling. Puoi usare la stessa tecnica di polling descritta in precedenza per attendere che l’annullamento sia finalizzato. I batch annullati terminano con uno stato ended e potrebbero contenere risultati parziali per le richieste elaborate prima dell’annullamento.
client = anthropic.Anthropic()
MESSAGE_BATCH_ID = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"
message_batch = client.messages.batches.cancel(
MESSAGE_BATCH_ID,
)
print(message_batch)La risposta mostra il batch in uno stato 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
}Usare la cache dei prompt con i Message Batches
La Message Batches API supporta la “prompt caching” (cache dei prompt), consentendoti potenzialmente di ridurre i costi e i tempi di elaborazione per le richieste batch. Gli sconti sui prezzi della cache dei prompt e dei Message Batches possono sommarsi, offrendo risparmi ancora maggiori quando entrambe le funzionalità vengono usate insieme. Tuttavia, poiché le richieste batch vengono elaborate in modo asincrono e concorrente, i cache hit sono forniti secondo il principio del massimo impegno. Gli utenti registrano tipicamente tassi di cache hit compresi tra il 30 percento e il 98 percento, a seconda dei loro modelli di traffico.
Per massimizzare la probabilità di cache hit nelle tue richieste batch:
- Includi blocchi
cache_controlidentici in ogni richiesta Message all’interno del tuo batch. - Mantieni un flusso costante di richieste per evitare che le voci di cache scadano dopo la loro durata di 5 minuti.
- Struttura le tue richieste per condividere quanto più contenuto memorizzato nella cache possibile.
Esempio di implementazione della cache dei prompt in un 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-5-5",
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-5-5",
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.",
}
],
),
),
]
)In questo esempio, entrambe le richieste nel batch includono messaggi di sistema identici e il testo completo di Orgoglio e pregiudizio contrassegnato con cache_control per aumentare la probabilità di cache hit.
Strumenti server e il ciclo agentico
Tutti gli strumenti server (ricerca web, recupero web, esecuzione di codice, connettori MCP, advisor e ricerca di strumenti) funzionano nelle richieste batch. Il worker del batch esegue lo stesso ciclo agentico lato server della Messages API sincrona.
Poiché non c’è alcuna connessione aperta da mantenere, il ciclo del batch può eseguire più iterazioni in un turno rispetto a una richiesta sincrona prima di restituire stop_reason: "pause_turn". Se un risultato del batch viene restituito con pause_turn, il turno non è stato completato; puoi continuarlo inviando il contenuto dell’assistente in pausa in una richiesta successiva (batch o sincrona), esattamente come mostrato nel modello di continuazione pause_turn.
Il worker del batch inoltre limita web_search per ciascuna organizzazione, in modo che l’elaborazione batch altamente concorrente non esaurisca il limite di velocità della ricerca web della tua organizzazione. Il batch ritenta automaticamente le richieste limitate; non devi gestirlo tu, ma batch di ricerca web molto grandi potrebbero richiedere più tempo per essere completati.
Output esteso (beta)
L’header beta output-300k-2026-03-24 aumenta il limite di max_tokens a 300.000 per le richieste batch che usano Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 o Claude Haiku 5.5. Includi l’header per generare output molto più lunghi del limite standard di 128k max_tokens in un singolo turno.
L’output esteso è disponibile solo sulla Message Batches API, non sulla Messages API sincrona.
Usa l’output esteso per la generazione di testi lunghi, come bozze della lunghezza di un libro e documentazione tecnica, estrazione esaustiva di dati strutturati, ampie strutture di generazione di codice e lunghe catene di ragionamento.
Una singola generazione da 300k token può richiedere più di un’ora per essere completata, quindi pianifica l’invio dei tuoi batch tenendo conto della finestra di elaborazione di 24 ore. Si applicano i prezzi standard dei batch (50 percento dei prezzi standard dell’API).
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-5-5",
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)Best practice per un batching efficace
Per usare la Batches API in modo efficace:
- Monitora regolarmente lo stato di elaborazione dei batch e implementa una logica di ripetizione appropriata per le richieste non riuscite.
- Usa valori
custom_idsignificativi per abbinare facilmente i risultati alle richieste, poiché l’ordine non è garantito. - Valuta la possibilità di suddividere dataset molto grandi in più batch per una migliore gestibilità.
- Esegui una prova di una singola struttura di richiesta con la Messages API per evitare errori di validazione.
Risoluzione dei problemi comuni
In caso di comportamenti imprevisti:
- Verifica che la dimensione totale della richiesta batch non superi 256 MB. Se la dimensione della richiesta è troppo grande, potresti ricevere un errore 413
request_too_large. - Controlla di usare modelli supportati per tutte le richieste nel batch.
- Assicurati che ogni richiesta nel batch abbia un
custom_idunivoco. - Assicurati che siano trascorsi meno di 29 giorni dal momento
created_atdel batch (non dal momentoended_atdell’elaborazione). Dopo 29 giorni, i risultati non sono più disponibili per il download. - Conferma che il batch non sia stato annullato.
Tieni presente che il fallimento di una richiesta in un batch non influisce sull’elaborazione delle altre richieste.
Archiviazione e privacy dei batch
-
Isolamento del Workspace: i batch sono isolati all’interno del Workspace in cui vengono creati. Possono essere accessibili solo da richieste API nello stesso Workspace o da utenti con il permesso di visualizzare i batch del Workspace nella Console.
-
Disponibilità dei risultati: i risultati del batch sono disponibili per 29 giorni dopo la creazione del batch, lasciando ampio tempo per il recupero e l’elaborazione.
Domande frequenti
L’elaborazione dei batch potrebbe richiedere fino a 24 ore, ma molti si completano prima. Il tempo effettivo di elaborazione dipende dalla dimensione del batch, dalla domanda attuale e dal volume delle tue richieste. È possibile che un batch scada e non si completi entro 24 ore.
Consulta Modelli supportati per l’elenco dei modelli supportati.
Sì, la Message Batches API supporta quasi tutte le funzionalità disponibili nella Messages API, inclusa la maggior parte delle funzionalità beta. Un piccolo numero di parametri (stream, speed, fallbacks e max_tokens: 0) non è supportato. Consulta Cosa può essere inserito in un batch per l’elenco completo.
La Message Batches API offre uno sconto del 50 percento su tutto l’utilizzo rispetto ai prezzi standard dell’API. Questo si applica ai token di input, ai token di output e a qualsiasi token speciale. Per maggiori informazioni sui prezzi, visita Prezzi.
No, una volta inviato, un batch non può essere modificato. Se devi apportare modifiche, annulla il batch corrente e inviane uno nuovo. Tieni presente che l’annullamento potrebbe non avere effetto immediato.
La Message Batches API ha limiti di velocità basati sulle richieste HTTP, oltre a limiti sul numero di richieste in attesa di elaborazione. Consulta Limiti di velocità della Message Batches API. L’utilizzo della Batches API non influisce sui limiti di velocità della Messages API.
Quando recuperi i risultati, ogni richiesta ha un campo result che indica se è succeeded, errored, canceled o expired. Per i risultati errored, vengono fornite informazioni aggiuntive sull’errore. Visualizza l’oggetto di risposta di errore nel riferimento APIAnteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro).
La Message Batches API è progettata con solide misure di privacy e separazione dei dati:
- I batch e i relativi risultati sono isolati all’interno del Workspace in cui sono stati creati. Ciò significa che possono essere accessibili solo da richieste API nello stesso Workspace.
- Ogni richiesta all’interno di un batch viene elaborata in modo indipendente, senza fuga di dati tra le richieste.
- I risultati sono disponibili solo per un tempo limitato (29 giorni) e seguono la politica di conservazione dei dati di Anthropic.
- Il download dei risultati del batch nella Console può essere disabilitato a livello di organizzazione o per singolo workspace.
Sì, è possibile usare la cache dei prompt con la Message Batches API. Tuttavia, poiché le richieste batch asincrone possono essere elaborate in modo concorrente e in qualsiasi ordine, i cache hit sono forniti secondo il principio del massimo impegno.
Disponibilità
Claude API
- API
- Messages API
- Managed Agents Non supportato
- Modelli
- Tutti i modelli
Claude Platform on AWS
- API
- Messages API
- Managed Agents Non supportato
- Modelli
- Tutti i modelli
Claude Models on Google Cloud (Anthropic managed)
- API
- Messages API
- Managed Agents Non supportato
- Modelli
- Tutti i modelli
Gestione dei dati
Panoramica sulla gestione dei datiEndpoint applicabili
/v1/messages/batches
Conservazione di 29 giorni; archiviazione asincrona richiesta. Scopri di più
L’elaborazione in batch archivia i dati di richiesta e risposta per un massimo di 29 giorni dopo la creazione del batch. Puoi eliminare un batch di messaggi in qualsiasi momento dopo l’elaborazione usando l’endpoint DELETE /v1/messages/batches/{batch_id}Anteprima disponibile con link al riferimento API (premi Tab finché il focus non entra nella scheda, Esc per tornare indietro). Per eliminare un batch in corso, annullalo prima. L’elaborazione asincrona richiede l’archiviazione lato server sia degli input sia degli output fino al completamento del batch e al recupero dei risultati.
Passaggi successivi
Ottieni citazioni naturali per le applicazioni RAG fornendo risultati di ricerca con attribuzione della fonte.
Riduci costi e latenza memorizzando nella cache i prefissi dei prompt condivisi tra le richieste in un batch.
Questa pagina ti è stata utile?