Source: https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/
Canonical: https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/
Language: it

# Anthropic: Claude Haiku 4.5

[Markdown](https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/index.md) · [JSON](https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/facts.json)

## [Anthropic: Claude Haiku 4.5](https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/)

Claude Haiku 4.5 è pensato per assistenti interattivi, supporto agli utenti, elaborazione quotidiana di informazioni e lavoro sul codice. Per le domande complesse supporta una modalità di ragionamento separata.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `claude-haiku-4-5-20251001-thinking`](https://ailoot.ai/models/it/claude-haiku-4-5-20251001-thinking/#method-0)

Informazioni sul modello

Questa descrizione illustra le funzionalità del modello. Gli input, gli output e le opzioni disponibili in Ailoot per il metodo selezionato sono elencati di seguito.

#### Quando conta la risposta a ogni passaggio

Anthropic ha progettato Claude Haiku 4.5 per assistenti conversazionali, supporto agli utenti, lavoro condiviso sul codice e prototipazione. Il modello è utile in un ciclo in cui una persona pone una domanda, riceve un risultato e precisa subito il passaggio successivo. Secondo Anthropic, questa versione presenta una bassa latenza di risposta; il tempo concreto dipende dall'istruzione e dall'applicazione.

Haiku 4.5 è pensato anche per elaborare un gran numero di attività separate. In un processo agentico gli si può affidare una sottoattività specifica, per poi trasmettere il risultato al resto del sistema. Tra gli ambiti descritti figurano programmazione, ragionamento e azioni nell'interfaccia. Le chiamate di strumenti e il controllo del computer sono possibili quando l'applicazione fornisce al modello i mezzi corrispondenti; una singola richiesta testuale non gli dà accesso all'ambiente di lavoro.

#### Risposta normale e budget manuale di ragionamento

Per le attività con più passaggi logici è previsto **extended thinking**: l'applicazione attiva esplicitamente il ragionamento e ne imposta il budget tramite `budget_tokens`. Quando il metodo supporta queste impostazioni, il budget manuale `budget_tokens` deve essere di almeno **1024 token** e inferiore a `max_tokens`, per lasciare spazio alla risposta finale. Orienta l'ampiezza dell'analisi, mentre `max_tokens` limita l'intero output. Haiku 4.5 utilizza precisamente la modalità manuale: il ragionamento adattivo e il controllo della profondità tramite `effort` non sono supportati in questa versione. Non è supportato neppure il ragionamento tra chiamate successive di strumenti.

È una distinzione utile nella scelta dell'attività. La modalità normale è adatta al dialogo diretto; il ragionamento attivo dà al modello spazio per elaborare codice o domande complesse. Il contenuto dell'istruzione continua a determinare quali informazioni analizzare e in quale forma presentare il risultato.

#### Materiali e limiti della versione

Il modello riceve **testo e immagini** e restituisce il risultato in forma testuale. La finestra di contesto è di **200 mila token**, la risposta massima di **64 mila token**. L'immagine è materiale da analizzare insieme alla domanda: il modello può spiegare il contenuto visibile e collegarlo all'istruzione testuale. Il supporto delle immagini in ingresso non implica la creazione o la modifica di immagini.

I formati dell'input visivo ordinario presso il produttore sono JPEG/PNG/GIF/WebP, con il primo fotogramma per le animazioni. Nell'analisi nativa il lato lungo è di 1568 pixel, con 1568 token visivi; le immagini più grandi vengono ridimensionate prima dell'analisi. Il supporto di file e parametri dipende dal metodo dell'applicazione.

Per questa versione Anthropic descrive uno stile di comunicazione conciso e diretto. È utile indicare in anticipo il livello di dettaglio desiderato, il formato del risultato e i vincoli dell'attività. Le conoscenze integrate hanno un riferimento affidabile a **febbraio 2025**; le informazioni su eventi successivi devono essere incluse nel materiale dell'istruzione oppure ottenute tramite gli strumenti disponibili all'applicazione. Alcune richieste possono essere rifiutate.

Se il metodo offre impostazioni di campionamento, non si possono impostare contemporaneamente `temperature` e `top_p`: per questa versione si sceglie uno dei due parametri.

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `claude-haiku-4-5-20251001-thinking`

[`claude-haiku-4-5-20251001-thinking`](https://ailoot.ai/models/it/#m=claude-haiku-4-5-20251001-thinking&route=Ultra&caller=claude-haiku-4-5-20251001-thinking&fmt=chat)

Anthropic /`claude-haiku-4-5-20251001-thinking`

### Introduzione

Claude Haiku 4.5 è pensato per assistenti interattivi, supporto agli utenti, elaborazione quotidiana di informazioni e lavoro sul codice. Per le domande complesse supporta una modalità di ragionamento separata.

Input accettati

Testo

Risultati

Testo

### Disponibile in Ailoot · input e metodi

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`

Tipi di input

`text`

Tipi di output

`text`

Formato di output

json o SSE

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti claude-haiku-4-5-20251001-thinking | Predefinito— |
| Campo`messages` | Tipo`message[]` | RequisitoObbligatorio | Valori e limiti Numero minimo di elementi: 1 | Predefinito— |
| Campo`messages[].role` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`messages[].content` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Si applica quando: Conversazione testuale | Predefinito— |
| Campo`stream` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse |

Combinazioni di materiali in input

**Testo** · Testo UTF8

`messages[].content`

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattoapplication/json |
| Parametro`required` | Contrattomodel, messages |
| Parametro`material_types` | Contrattotext |
| Parametro`messages` | ContrattoArray di messaggi con struttura role/content |
| Parametro`file_material` | ContrattoDocumento UTF-8 effettivo inserito come testo letterale; nessun ID di file dedotto |
| Parametro`optional_controls` | Contrattostream |
| Parametro`control_scope` | ContrattoConversazione testuale; stream è un booleano e per impostazione predefinita vale false. |
| Parametro`output_modalities` | Contrattotext |
| Parametro`hosted_operations` | Contrattofalse |
| Parametro`multimodal_input_binding` | Contrattonull |

Alias del metodo: `/chat/completions`

Ciclo di vita: `synchronous_or_streamed`

Invia l’ID esatto del modello con messages.

La lunghezza del contesto non è un limite di uscita.

Un file di testo può fornire testo letterale; gli ingressi immagine/audio/oggetto file richiedono un’associazione esatta.

### Tariffe

Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato.

Modalità rapida

Non specificato Quando è selezionata la modalità rapida

Modalità flex

Non specificato Quando è selezionata la modalità flex

Sforzo massimo di ragionamento

Non specificato Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default)

#### Tariffe Ailoot

#### Prezzi per configurazione

| Configurazione | Listino delle tariffe | Costo |
| --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Costo Input · Token in input **$0.002** / 1K token Output · Token in output **$0.01** / 1K token Input · Lettura dalla cache **$0.0002** / 1K token Input · Scrittura nella cache **$0.0025** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token |

Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. [Come funzionano la prenotazione e l’addebito finale →](https://ailoot.ai/docs/it/billing/reserve/)

### Esempi di richieste

#### Ailoot Ultra · OpenAI Chat

curlPython SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"claude-haiku-4-5-20251001-thinking","messages":[{"role":"user","content":"hello"}],"stream":false}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="claude-haiku-4-5-20251001-thinking", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

### Ricevi e salva i risultati

#### Ailoot Ultra · OpenAI Chat

json o SSE

##### Conserva tutti i risultati completati

Conserva ogni risposta, file e parte di contenuto restituiti per intero.

Conserva ogni scelta con contenuto, chiamate agli strumenti e ragionamento. In SSE assembla i delta per indice di scelta e strumento e conserva il motivo finale di completamento e i dati di utilizzo.

##### Se occorre verificare la risposta originale

Conserva gli ID e le intestazioni di richiesta/risposta. Non viene fornito alcun URL generico per recuperare un’attività testuale.

Campi della risposta

| Campo | Tipo |
| --- | --- |
| Campo`choices[].index` | Tipointeger |
| Campo`choices[].message.content` | Tipostring\|null |
| Campo`choices[].message.tool_calls` | Tipotool\_call\[\] |
| Campo`choices[].message.reasoning_content` | Tipostring |
| Campo`choices[].message.reasoning_details` | Tipoobject\|array |
| Campo`choices[].finish_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |

Errori e passaggi successivi

| Risposta | Condizione | Passaggio successivo |
| --- | --- | --- |
| Risposta400 · `invalid_request_error` | CondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validi | Passaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot Ultra** [`claude-haiku-4-5-20251001-thinking`](https://ailoot.ai/models/it/#m=claude-haiku-4-5-20251001-thinking&route=Ultra&caller=claude-haiku-4-5-20251001-thinking&fmt=chat)

#### Alias dei percorsi dei metodi

`/chat/completions`

#### ID di chiamata correlati

[`claude-haiku-4-5-20251001-thinking`](https://ailoot.ai/models/it/#m=claude-haiku-4-5-20251001-thinking&route=Ultra&caller=claude-haiku-4-5-20251001-thinking&fmt=chat)

FAQ · Anthropic: Claude Haiku 4.5

Quali input e risultati sono disponibili?

`POST /v1/chat/completions` · `claude-haiku-4-5-20251001-thinking`: `text` → `text`

Quali campi usa la richiesta?

`POST /v1/chat/completions` · `claude-haiku-4-5-20251001-thinking`: `model`, `messages`, `stream`

Quali limiti si applicano?

`POST /v1/chat/completions` · `claude-haiku-4-5-20251001-thinking`: `messages.min_items`: `1`

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

## L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

## Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento

Scegli un piano scontato per richieste regolari.

Codice fino al 50%

Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.

Spese nella cronologia

Modello, token e importo sono salvati per ogni richiesta.

[Scegli abbonamento](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale

Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.

Licenza reseller

Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.

Documenti sul sito

Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

[Richiedi licenza reseller](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.
