# API GPT Terra 6.1 (https://wanapi.app/it/docs/gpt-6-1-terra)





Usa **GPT Terra 6.1** con il formato OpenAI Responses o Chat Completions e la tua chiave Wan API. [Confronta i modelli GPT](/it/docs/gpt-api).

## Impostazioni del modello [#impostazioni-del-modello]

| Impostazione                   | GPT Terra 6.1                                   |
| ------------------------------ | ----------------------------------------------- |
| ID del modello nella richiesta | `gpt-6.1-terra`                                 |
| Input / output                 | Testo e immagini / testo                        |
| Finestra di contesto           | 1,050,000 token                                 |
| Input massimo                  | 922,000 token                                   |
| Output massimo                 | 128,000 token, incluso il ragionamento          |
| Impegno di ragionamento        | `none`, `low`, `medium`, `high`, `xhigh`, `max` |
| Impegno predefinito            | medium                                          |

Questi sono i limiti nativi del modello. Le richieste dipendono anche dal canale disponibile e dai limiti dell’account. Gli input audio e video non sono supportati.

## Connettersi e inviare una richiesta [#connettersi-e-inviare-una-richiesta]

Crea una chiave nelle [impostazioni delle chiavi API](/it/settings/apikeys). Conservala sul server come `WAN_API_KEY`. Un’unica chiave e lo stesso saldo prepagato funzionano con tutti i modelli e gruppi. Usa l’ID esatto del modello, incluso il punto decimale negli ID 6.1.

```bash
curl https://api.wanapi.app/v1/responses \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-terra",
    "input": "Explain the purpose of a database index in three sentences.",
    "reasoning": {"effort": "low"},
    "max_output_tokens": 1024
  }'
```

```python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["WAN_API_KEY"],
    base_url="https://api.wanapi.app/v1",
)
response = client.responses.create(
    model="gpt-6.1-terra",
    input="Explain the purpose of a database index in three sentences.",
    reasoning={"effort": "low"},
    max_output_tokens=1024,
)
print(response.output_text)
```

## Parametri di Responses [#parametri-di-responses]

| Campo                                                                | Obbligatorio | Specifica                                                                                                                    |
| -------------------------------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
| `model`                                                              | Sì           | `gpt-6.1-terra`.                                                                                                             |
| `input`                                                              | Sì           | Stringa del prompt o array di elementi di input.                                                                             |
| `instructions`                                                       | No           | Istruzioni di sistema o dello sviluppatore.                                                                                  |
| `max_output_tokens`                                                  | No           | Limite di output, incluso il ragionamento; fino a 128,000 token.                                                             |
| `reasoning.effort`                                                   | No           | none, low, medium, high, xhigh, max.                                                                                         |
| `reasoning.summary`                                                  | No           | `auto`, `concise` o `detailed`.                                                                                              |
| `text.verbosity`                                                     | No           | `low`, `medium` o `high`.                                                                                                    |
| `text.format`                                                        | No           | Testo o output strutturato, ad esempio uno schema JSON supportato.                                                           |
| `stream`                                                             | No           | `true` per gli eventi SSE; altrimenti una risposta completa.                                                                 |
| `tools`, `tool_choice`                                               | No           | Dichiarazione e selezione degli strumenti. Le funzioni client vengono eseguite dalla tua applicazione.                       |
| `parallel_tool_calls`, `max_tool_calls`                              | No           | Concorrenza degli strumenti e limiti delle chiamate, dove supportati.                                                        |
| `include`                                                            | No           | Campi aggiuntivi nella risposta, ad esempio `reasoning.encrypted_content`.                                                   |
| `metadata`, `store`                                                  | No           | Metadati e preferenza di conservazione della risposta.                                                                       |
| `previous_response_id`                                               | No           | ID di una risposta precedente, solo finché resta disponibile presso il servizio a monte che gestisce la richiesta.           |
| `truncation`                                                         | No           | Criterio di troncamento dell’input.                                                                                          |
| `prompt_cache_key`, `prompt_cache_retention`, `prompt_cache_options` | No           | Instradamento e conservazione della cache, se supportati dal canale.                                                         |
| `reasoning.mode`, `reasoning.context`                                | No           | Inoltrati al servizio a monte; si applicano le restrizioni del modello. Omettili se il tuo flusso di lavoro non li richiede. |
| `context_management`, `conversation`, `prompt`                       | No           | Impostazioni native del contesto o dei prompt salvati, se supportate dal servizio a monte.                                   |

## Ragionamento e strumenti [#ragionamento-e-strumenti]

Terra supporta `none` per le richieste senza ragionamento. Le chiamate agli strumenti richiedono l’API Responses, anche quando il ragionamento è disabilitato.

Ometti `temperature`, `top_p` e `top_logprobs` quando il ragionamento è attivo. Per Chat Completions, ometti anche `logprobs`; per Responses, non richiedere `message.output_text.logprobs` in `include`.

Il limite di output comprende sia il ragionamento sia il testo visibile. Il limite può essere raggiunto prima che venga prodotta una risposta completa. Un impegno maggiore può richiedere più token di output e più tempo.

Per l’output strutturato, usa `text.format` con `type: "json_schema"`, un nome e uno schema supportato dal modello. Lo schema vincola la struttura, non l’accuratezza dei fatti. Quando prosegui una conversazione con strumenti, restituisci i risultati delle funzioni client con l’ID originale della chiamata.

## Funzioni API attualmente disponibili [#funzioni-api-attualmente-disponibili]

Il gateway accetta `POST /v1/responses` e `POST /v1/chat/completions`. La disponibilità dei modelli dipende dai canali configurati; verifica con una richiesta autenticata a `GET /v1/models` prima dell’integrazione. L’assenza di prezzi nella tabella seguente non conferma che un modello sia pronto a ricevere chiamate.

Il livello di compatibilità inoltra i campi riconosciuti, non qualsiasi campo JSON. L’attuale DTO di Responses non include i campi nativi `access_programs`, `image` o `background`. Non presumere che un campo ignorato abbia avuto effetto. Anche `service_tier` e `safety_identifier` possono essere filtrati dalle impostazioni del canale.

Questa integrazione non fornisce un’API Files, un’API Batch o un flusso di polling per le risposte in background. Usa risposte sincrone o SSE. Gli strumenti integrati dipendono dalla disponibilità a monte e possono prevedere costi separati; dichiarare uno strumento non garantisce che l’intera sessione sia disponibile qui.

## Immagini in input [#immagini-in-input]

Usa l’URL HTTP(S) pubblicamente accessibile di un’immagine che ospiti. Inserisci l’immagine e la domanda in un elemento di input dell’utente:

```json
{"role":"user","content":[
  {"type":"input_image","image_url":"https://example.com/chart.png"},
  {"type":"input_text","text":"What does this chart show?"}
]}
```

Sostituisci l’URL di esempio con quello della tua immagine. Questa integrazione non fornisce un servizio di caricamento o archiviazione dei file multimediali.

## Chat Completions [#chat-completions]

```bash
curl https://api.wanapi.app/v1/chat/completions \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-terra",
    "messages": [{"role":"user","content":"Explain what a database index does."}],
    "reasoning_effort": "low",
    "max_completion_tokens": 1024
  }'
```

Leggi `choices[0].message.content`. Chat Completions usa `messages`, `reasoning_effort` e `max_completion_tokens`; Responses usa `input`, `reasoning.effort` e `max_output_tokens`. Per i messaggi con immagini in Chat Completions, usa `type: "image_url"` e `image_url: {"url":"https://..."}`.

## Prezzi [#prezzi]

USD per 1 milione di token

Le tariffe attuali includono il moltiplicatore di ciascun gruppo. I prezzi vengono memorizzati nella cache per un massimo di 2 minuti.

Un'unica chiave API funziona con tutti i modelli e gruppi. Predefinito indica il primo gruppo idoneo nell'ordine di instradamento automatico; la richiesta viene addebitata alle tariffe del gruppo effettivamente selezionato.

### GPT Terra 6.1

`gpt-6.1-terra`

| Token fatturabili | gpt · Predefinito · ≤ 272.000 token di input | gpt · Predefinito · > 272.000 token di input |
| --- | ---: | ---: |
| Input (non in cache) | 0,1 USD | 0,2 USD |
| Output | 0,5 USD | 0,75 USD |
| Lettura dalla cache | 0,005 USD | 0,01 USD |
| Scrittura nella cache | 0,125 USD | 0,25 USD |

La soglia si basa su: Token di input non in cache. La fascia selezionata si applica all'intera richiesta, non solo ai token che superano la soglia.

— indica che non è disponibile una tariffa verificata; non significa che il servizio sia gratuito.

Le tariffe della cache si applicano solo quando la risposta riporta il relativo utilizzo. Non conteggiare nuovamente i token in cache come input non in cache.

Moltiplica il numero di token fatturabili di ciascun tipo per la relativa tariffa e dividi per 1,000,000. Il ragionamento è incluso nei token di output e non viene addebitato una seconda volta. L’input in cache non deve essere conteggiato anche come input non in cache. Usa soltanto l’utilizzo della cache riportato nella risposta; la voce di scrittura nella cache in tabella non implica il supporto di tutte le modalità di conservazione.

Per i prezzi basati sulla lunghezza, la fascia applicabile copre l’intera richiesta. Consulta la soglia e il criterio di conteggio dell’input nella tabella, senza presumere una tariffa fissa. Le richieste senza header di gruppo usano `gpt`. Per scegliere un gruppo con Responses o Chat Completions, invia `X-Model-Group: gpt` oppure `X-Model-Group: gpt-0.7`. `gpt-0.7` è disponibile solo per Luna, Sol e Astra; Terra supporta solo `gpt`. Una selezione esplicita non passa mai a un altro gruppo. Mantieni invariato l’ID del modello; i suffissi di gruppo non sono supportati.

## Risposte e streaming [#risposte-e-streaming]

Un risultato completato di Responses contiene `id`, `model`, `status`, `output` e `usage`. `output` può contenere ragionamento, chiamate agli strumenti e messaggi; non presumere che il primo elemento sia testo. L’helper `output_text` dell’SDK OpenAI raccoglie l’output testuale.

Imposta `stream: true` e usa `curl -N` per SSE. Gestisci `response.created`, `response.output_text.delta`, `response.completed`, le risposte incomplete e gli errori. La risposta finale contiene i dati di utilizzo. Chat Completions trasmette `choices[].delta`; richiedi `stream_options: {"include_usage":true}` per ricevere il blocco finale con i dati di utilizzo.

## Registri di utilizzo ed errori [#registri-di-utilizzo-ed-errori]

I [registri LLM](/it/usage) mostrano le chiamate completate negli ultimi 7 giorni, con modello, token di input, token di output e costo. Filtra per `gpt-6.1-terra`. Per immagini e video, consulta i [registri delle attività](/it/tasks).

In caso di errore, esamina lo stato HTTP e l’oggetto `error`. Controlla la chiave, il [saldo](/it/docs/balance), l’ID esatto del modello e la combinazione di parametri. Se una richiesta o uno stream si interrompe, controlla i registri prima di riprovare: una nuova richiesta può comportare un altro addebito.

## Riferimenti del modello [#riferimenti-del-modello]

* [Specifiche ufficiali di GPT Terra 6.1](https://developers.openai.com/api/docs/models/gpt-6.1-terra)
* [Riferimento API Responses](https://developers.openai.com/api/reference/resources/responses/methods/create)
* [Modelli GPT e ragionamento](https://developers.openai.com/api/docs/guides/latest-model)
