Source: https://ailoot.ai/models/it/ernie-x1-turbo-32k/
Canonical: https://ailoot.ai/models/it/ernie-x1-turbo-32k/
Language: it

# ernie-x1-turbo-32k

[Markdown](https://ailoot.ai/models/it/ernie-x1-turbo-32k/index.md) · [JSON](https://ailoot.ai/models/it/ernie-x1-turbo-32k/facts.json)

## [ernie-x1-turbo-32k](https://ailoot.ai/models/it/ernie-x1-turbo-32k/)

ERNIE X1 Turbo è il profilo di ragionamento di Baidu per attività testuali matematiche, logiche e connesse a strumenti. La specifica AI Studio distingue un contesto di 32K, un input massimo di 24K, impostazioni dell’output finale fino a 16.384 token e una lunghezza di ragionamento separata di 16K.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `ernie-x1-turbo-32k`](https://ailoot.ai/models/it/ernie-x1-turbo-32k/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `ernie-x1-turbo-32k`](https://ailoot.ai/models/it/ernie-x1-turbo-32k/#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.

ERNIE X1 Turbo è il profilo di modello di ragionamento di Baidu per domande che richiedono analisi estesa, risoluzione di problemi logici e attività testuali connesse a strumenti. Il produttore identifica Turbo come una versione potenziata della linea X1. Il suo profilo documentato dal produttore di 32K resta separato da ERNIE X1.1 Preview e ERNIE 5.0 Thinking, che hanno budget di input e generazione differenti.

#### Prepara un problema di ragionamento completo

Fornisci la domanda, i valori dati, i vincoli e il tipo di risultato necessario. Un compito matematico può richiedere una soluzione il cui calcolo decisivo sia verificabile; un compito di pianificazione può confrontare alternative rispetto a condizioni dichiarate. Mantieni le ipotesi separate dai fatti forniti e identifica ciò che rimane sconosciuto. In questo modo il processo di ragionamento riceve un problema delimitato, anziché il permesso di inventare requisiti mancanti.

Per una domanda tecnica, includi il passaggio originale o il frammento di codice pertinente e il comportamento da indagare. Richiedi un controesempio concreto o una spiegazione se due implementazioni differiscono. L’elaborato utile deve rendere chiare la conclusione e le condizioni che la determinano. Verifica i valori importanti e il comportamento proposto rispetto alla fonte, anziché considerare una lunga analisi generata come prova di correttezza.

#### Budget di contesto, output finale e ragionamento

La tabella dei modelli AI Studio del produttore indica un contesto di 32K, un input massimo di 24K e un’impostazione dell’output finale da 2 a 16.384 token, con 2K come valore predefinito documentato. Indica separatamente una lunghezza di ragionamento di 16K per X1 Turbo. Questi campi hanno ruoli distinti; scegli di conseguenza il materiale originale e l’elaborato finale richiesto, anziché interpretare il numero del contesto come una promessa di una risposta altrettanto lunga.

Mantieni la risposta finale separata dall’eventuale materiale di ragionamento restituito dal flusso del produttore. Un confronto può presentare prima la raccomandazione e conservare le condizioni che la fondano. Una risposta sul codice può identificare il caso di input esatto e il risultato atteso. Conserva la domanda originale e le evidenze insieme all’elaborato completato, così che una richiesta successiva possa esaminare un passaggio irrisolto.

#### Funzioni e informazioni attuali

L’indice delle funzionalità del produttore elenca X1 Turbo per le chiamate di funzione e le attività potenziate dalla ricerca. Definisci lo scopo e gli argomenti di ogni funzione applicativa, quindi restituisci il risultato effettivo quando il modello la richiede. Il modello fornisce una richiesta strutturata; l’applicazione circostante esegue l’operazione. Una ricerca proposta è distinta da un record recuperato, e un’azione richiesta è distinta da un risultato completato.

Per una domanda basata sulle fonti, conserva il materiale recuperato insieme alla risposta e verifica se sostiene l’affermazione. Un fatto dinamico deve provenire da evidenze attuali, anziché da una risposta non supportata basata sulla memoria. Considera l’integrazione di funzioni e ricerca come il flusso connesso del produttore, nel quale sono le evidenze effettivamente restituite a determinare ciò che la risposta può concludere responsabilmente.

#### Conserva l’edizione X1 Turbo insieme al risultato

Il profilo X1 Turbo da 32K è un flusso testuale di ragionamento, non la più ampia specifica di generazione multimodale nativa di un’altra famiglia ERNIE. I suoi budget di input, output finale e ragionamento restano quelli del profilo del produttore selezionato. Un passaggio di consegne utile può contenere la soluzione, il confronto o la risposta informata dagli strumenti, insieme ai passaggi originali e ai risultati delle operazioni completate. Questo consente una continuazione mirata, preservando il compito originale e la sua incertezza.

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `ernie-x1-turbo-32k`

[`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=chat)

Baidu /`ernie-x1-turbo-32k`

### Introduzione

ERNIE X1 Turbo è il profilo di ragionamento di Baidu per attività testuali matematiche, logiche e connesse a strumenti. La specifica AI Studio distingue un contesto di 32K, un input massimo di 24K, impostazioni dell’output finale fino a 16.384 token e una lunghezza di ragionamento separata di 16K.

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 ernie-x1-turbo-32k | 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.00033** / 1K token Output · Token in output **$0.00132** / 1K token Input · Lettura dalla cache **$0** / 1K token Input · Scrittura nella cache **$0** / 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":"ernie-x1-turbo-32k","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="ernie-x1-turbo-32k", 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** [`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=chat)

#### Alias dei percorsi dei metodi

`/chat/completions`

#### ID di chiamata correlati

[`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `ernie-x1-turbo-32k`

[`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=messages)

Baidu /`ernie-x1-turbo-32k`

### Introduzione

ERNIE X1 Turbo è il profilo di ragionamento di Baidu per attività testuali matematiche, logiche e connesse a strumenti. La specifica AI Studio distingue un contesto di 32K, un input massimo di 24K, impostazioni dell’output finale fino a 16.384 token e una lunghezza di ragionamento separata di 16K.

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 ernie-x1-turbo-32k | 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

| Configurazione | Listino delle tariffe | Costo |
| --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Costo Input · Token in input **$0.00033** / 1K token Output · Token in output **$0.00132** / 1K token Input · Lettura dalla cache **$0** / 1K token Input · Scrittura nella cache **$0** / 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": "ernie-x1-turbo-32k",
  "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': 'ernie-x1-turbo-32k', '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': 'ernie-x1-turbo-32k', '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** [`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=messages)

#### Alias dei percorsi dei metodi

`/chat/completions`

#### ID di chiamata correlati

[`ernie-x1-turbo-32k`](https://ailoot.ai/models/it/#m=ernie-x1-turbo-32k&route=Ultra&caller=ernie-x1-turbo-32k&fmt=messages)

FAQ · ernie-x1-turbo-32k

Quali input e risultati sono disponibili?

`POST /v1/chat/completions` · `ernie-x1-turbo-32k`: `text` → `text` `POST /v1/messages` · `ernie-x1-turbo-32k`: `text` → `json`, `sse`

Quali campi usa la richiesta?

`POST /v1/chat/completions` · `ernie-x1-turbo-32k`: `model`, `messages`, `stream` `POST /v1/messages` · `ernie-x1-turbo-32k`: `model`, `messages`, `max_tokens`, `stream`

Quali limiti si applicano?

`POST /v1/chat/completions` · `ernie-x1-turbo-32k`: `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.