Source: https://ailoot.ai/models/it/scaledown-extract/
Canonical: https://ailoot.ai/models/it/scaledown-extract/
Language: it

# ScaleDown: Extract

[Markdown](https://ailoot.ai/models/it/scaledown-extract/index.md) · [JSON](https://ailoot.ai/models/it/scaledown-extract/facts.json)

## [ScaleDown: Extract](https://ailoot.ai/models/it/scaledown-extract/)

Extract individua in testi, immagini e documenti le entità descritte dal chiamante. Definisci i campi in inglese corrente, poi conserva i passaggi corrispondenti, i punteggi di confidenza, gli offset dei caratteri e il contesto circostante. L’OCR integrato supporta scansioni e PDF, con un contesto dichiarato di 1.000.000 di token per i flussi di lavoro documentali.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `scaledown/extract`](https://ailoot.ai/models/it/scaledown-extract/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `scaledown/extract`](https://ailoot.ai/models/it/scaledown-extract/#method-1)

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.

Extract è il modello di ScaleDown per l’estrazione di entità guidata da descrizioni. Invece di scegliere da un unico insieme fisso di tipi di entità, il chiamante descrive in inglese corrente le informazioni da trovare. Il modello restituisce i passaggi corrispondenti con confidenza, offset dei caratteri e contesto circostante, rendendo più semplice ricollegare il risultato al materiale di origine.

#### Descrivi i campi che ti servono

Definisci ciascuna entità richiesta in funzione di uno scopo aziendale concreto. Un flusso di lavoro per le fatture può cercare identificativi dei documenti, date e importi così come sono scritti. Un flusso per i contratti può cercare le parti nominate, le scadenze o determinati obblighi. Un flusso per le email può cercare recapiti o un’azione richiesta.

Descrivi il significato di un campo senza affidarti soltanto al suo nome breve. Distingui una data di emissione da una scadenza di pagamento, oppure il nome di una persona da quello di un’organizzazione. Quando diversi campi hanno formulazioni simili, assegna a ciascuno una definizione che aiuti a mantenere separate le corrispondenze restituite.

#### Conserva la corrispondenza e le prove che la sostengono

Un risultato di estrazione utile conserva il passaggio originale insieme agli offset e al testo circostante. Questi valori permettono all’applicazione di identificare l’origine di una corrispondenza e a un revisore di esaminare le prove senza cercare di nuovo nell’intero documento. Mantieni il valore di confidenza associato alla corrispondenza, invece di considerare tutti i passaggi restituiti ugualmente certi.

Se un flusso di lavoro richiede una data normalizzata, un importo convertito o un altro valore derivato, conserva il testo originale accanto alla trasformazione successiva. L’estrazione di entità identifica ciò che dice il documento; l’applicazione decide quali normalizzazioni e regole di validazione applicare alle prove restituite.

#### Scansioni, documenti e input lunghi

La gamma di input dichiarata per il modello comprende testo, immagini e file come i PDF, con OCR integrato per i documenti scansionati. Usa materiale di origine leggibile e conserva gli identificativi di documenti e pagine quando sono importanti per la revisione. Una scansione di scarsa qualità può rendere ambiguo un campo: esamina quindi il contesto restituito prima di accettare un valore critico.

La finestra di contesto dichiarata è di 1.000.000 di token. Per un documento o una raccolta di grandi dimensioni, mantieni coerenti le definizioni delle entità richieste e associa ogni risultato al materiale da cui proviene. Lo stesso insieme di definizioni può aiutare un’applicazione a confrontare i campi estratti da contratti, fatture, messaggi o trascrizioni.

#### Output testuale e validazione successiva

La modalità di output dichiarata è il testo. Usa il flusso di estrazione che circonda il modello per validare qualsiasi struttura di record leggibile da una macchina di cui abbia bisogno. Conserva il testo corrispondente e il contesto di origine prima di memorizzare o trasformare il risultato.

Un artefatto finale utile contiene il nome dell’entità richiesta, il testo originale corrispondente, la posizione o il contesto pertinente e la confidenza da esaminare. Mantieni visibili le corrispondenze irrisolte o concorrenti, invece di inventare un campo mancante. In questo modo ottieni un record di estrazione basato su prove, pronto per controlli e trasformazioni successivi.

- Tipi di entità descritti in inglese corrente.
- Passaggi corrispondenti con confidenza, offset dei caratteri e contesto circostante.
- OCR integrato per immagini scansionate e PDF.
- Input di testo, immagini e file con un contesto dichiarato di 1.000.000 di token.
- Risultati testuali adatti all’estrazione di campi basata su prove.

- **Estrazione dei campi delle fatture** — Fatture e definizioni degli identificativi, delle date o degli importi da trovare. Campi corrispondenti della fonte con le relative prove conservate.
- **Preparazione della revisione dei contratti** — Contratti e definizioni precise di parti, date od obblighi. Passaggi estratti per una successiva revisione legale od operativa.
- **Acquisizione delle email** — Messaggi ed entità richieste dal flusso di lavoro. Record di contatti o richieste collegati alle prove.
- **Acquisizione di informazioni da documenti scansionati** — Scansioni/PDF leggibili e definizioni stabili delle entità. Corrispondenze con contesto di origine e confidenza per la validazione.

- **Contesto** — Finestra di contesto dichiarata: 1.000.000 di token.
- **Prove del risultato** — Conserva passaggi, offset e contesto circostante prima di applicare normalizzazioni successive.
- **Contratto di output** — L’output dichiarato è testo; per questo modello non sono elencati JSON vincolato da uno schema e chiamate a funzioni.
- **Definizioni dei campi** — La selezione delle entità è guidata dalle descrizioni fornite, anziché da un’unica tassonomia fissa.

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

[`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=chat)

ScaleDown /`scaledown/extract`

### Introduzione

Extract individua in testi, immagini e documenti le entità descritte dal chiamante. Definisci i campi in inglese corrente, poi conserva i passaggi corrispondenti, i punteggi di confidenza, gli offset dei caratteri e il contesto circostante. L’OCR integrato supporta scansioni e PDF, con un contesto dichiarato di 1.000.000 di token per i flussi di lavoro documentali.

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 scaledown/extract | 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

Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative.

| Configurazione | Listino delle tariffe | Token di contesto, più di | Token di contesto, fino al limite incluso | Costo |
| --- | --- | --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Token di contesto, più di— | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.0001** / 1K token Output · Token in output **$0** / 1K token Input · Lettura dalla cache **—** / 1K token Input · Scrittura nella cache **—** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token |
| ConfigurazioneFascia 1 di lunghezza della richiesta | Listino delle tariffe— | Token di contesto, più di0 | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.0001** / 1K token Output · Token in output **$0** / 1K token Input · Lettura dalla cache **—** / 1K token Input · Scrittura nella cache **—** / 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":"scaledown/extract","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="scaledown/extract", 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** [`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=chat)

#### Alias dei percorsi dei metodi

`/chat/completions`

#### ID di chiamata correlati

[`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `scaledown/extract`

[`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=messages)

ScaleDown /`scaledown/extract`

### Introduzione

Extract individua in testi, immagini e documenti le entità descritte dal chiamante. Definisci i campi in inglese corrente, poi conserva i passaggi corrispondenti, i punteggi di confidenza, gli offset dei caratteri e il contesto circostante. L’OCR integrato supporta scansioni e PDF, con un contesto dichiarato di 1.000.000 di token per i flussi di lavoro documentali.

Input accettati

Testo

Risultati

json · sse

### Disponibile in Ailoot · input e metodi

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`

Tipi di input

`text`

Tipi di output

`json`, `sse`

Formato di output

JSON o SSE

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti scaledown/extract | Predefinito— |
| Campo`messages` | Tipo`message[]` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`messages[].role` | Tipo`string` | RequisitoObbligatorio | Valori e limiti user, assistant | Predefinito— |
| Campo`messages[].content` | Tipo`string` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`stream` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse |

Combinazioni di materiali in input

**Testo** · Testo UTF-8

`Stringa messages[].content`

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattoapplication/json |
| Parametro`required` | Contrattomodel, messages, max\_tokens |
| Parametro`optional_controls` | Contrattostream |
| Parametro`material_types` | Contrattotext |
| Parametro`text_file_material` | ContrattoLeggi il documento UTF-8 effettivo e inserisci il testo nell’ingresso indicato o nella stringa del contenuto del messaggio. |

Ciclo di vita: `synchronous_or_streamed`

### 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

Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative.

| Configurazione | Listino delle tariffe | Token di contesto, più di | Token di contesto, fino al limite incluso | Costo |
| --- | --- | --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Token di contesto, più di— | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.0001** / 1K token Output · Token in output **$0** / 1K token Input · Lettura dalla cache **—** / 1K token Input · Scrittura nella cache **—** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token |
| ConfigurazioneFascia 1 di lunghezza della richiesta | Listino delle tariffe— | Token di contesto, più di0 | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.0001** / 1K token Output · Token in output **$0** / 1K token Input · Lettura dalla cache **—** / 1K token Input · Scrittura nella cache **—** / 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 · Anthropic Messages

Corpo JSON minimo completocurl · usa il tuo documento UTF-8Python · salva il risultato completo

```json
{
  "model": "scaledown/extract",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'scaledown/extract', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```

```python
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'scaledown/extract', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```

### Ricevi e salva i risultati

#### Ailoot Ultra · Anthropic Messages

JSON o SSE

##### Conserva tutti i risultati completati

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

Conserva tutti i blocchi di contenuto, le firme di ragionamento e gli ID effettivi di utilizzo degli strumenti. Assembla tutti i delta dei blocchi SSE; il primo blocco di testo non è l’uscita completa.

##### 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`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_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** [`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=messages)

#### Alias dei percorsi dei metodi

`/chat/completions`

#### ID di chiamata correlati

[`scaledown/extract`](https://ailoot.ai/models/it/#m=scaledown%2Fextract&route=Ultra&caller=scaledown%2Fextract&fmt=messages)

FAQ · ScaleDown: Extract

Quali input e risultati sono disponibili?

`POST /v1/chat/completions` · `scaledown/extract`: `text` → `text` `POST /v1/messages` · `scaledown/extract`: `text` → `json`, `sse`

Quali campi usa la richiesta?

`POST /v1/chat/completions` · `scaledown/extract`: `model`, `messages`, `stream` `POST /v1/messages` · `scaledown/extract`: `model`, `messages`, `max_tokens`, `stream`

Quali limiti si applicano?

`POST /v1/chat/completions` · `scaledown/extract`: `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.