# API GPT Luna 6 (https://wanapi.app/fr/docs/gpt-6-luna)





Utilisez **GPT Luna 6** au format OpenAI Responses ou Chat Completions avec votre clé Wan API. [Comparer les modèles GPT](/fr/docs/gpt-api).

## Caractéristiques du modèle [#caractéristiques-du-modèle]

| Caractéristique                       | GPT Luna 6                                      |
| ------------------------------------- | ----------------------------------------------- |
| Identifiant du modèle dans la requête | `gpt-6-luna`                                    |
| Entrée / sortie                       | Texte et images / texte                         |
| Fenêtre de contexte                   | 1 050 000 tokens                                |
| Entrée maximale                       | 922 000 tokens                                  |
| Sortie maximale                       | 128 000 tokens, raisonnement compris            |
| Effort de raisonnement                | `none`, `low`, `medium`, `high`, `xhigh`, `max` |
| Effort par défaut                     | medium                                          |

Il s’agit des limites natives du modèle. Les requêtes dépendent aussi du canal disponible et des limites du compte. Les entrées audio et vidéo ne sont pas prises en charge.

## Se connecter et envoyer une requête [#se-connecter-et-envoyer-une-requête]

Créez une clé dans les [paramètres des clés API](/fr/settings/apikeys). Conservez-la sur votre serveur sous le nom `WAN_API_KEY`. Une seule clé et le même solde prépayé donnent accès aux modèles et aux groupes. Utilisez l’identifiant exact du modèle, y compris le point décimal des identifiants 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-luna",
    "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-luna",
    input="Explain the purpose of a database index in three sentences.",
    reasoning={"effort": "low"},
    max_output_tokens=1024,
)
print(response.output_text)
```

## Paramètres de Responses [#paramètres-de-responses]

| Champ                                                                | Obligatoire | Spécification                                                                                                               |
| -------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------- |
| `model`                                                              | Oui         | `gpt-6-luna`.                                                                                                               |
| `input`                                                              | Oui         | Prompt sous forme de chaîne ou tableau d’éléments d’entrée.                                                                 |
| `instructions`                                                       | Non         | Instructions système ou développeur.                                                                                        |
| `max_output_tokens`                                                  | Non         | Budget de sortie, raisonnement compris ; jusqu’à 128 000 tokens.                                                            |
| `reasoning.effort`                                                   | Non         | none, low, medium, high, xhigh, max.                                                                                        |
| `reasoning.summary`                                                  | Non         | `auto`, `concise` ou `detailed`.                                                                                            |
| `text.verbosity`                                                     | Non         | `low`, `medium` ou `high`.                                                                                                  |
| `text.format`                                                        | Non         | Texte ou sortie structurée, par exemple un schéma JSON Schema pris en charge.                                               |
| `stream`                                                             | Non         | `true` pour recevoir des événements SSE ; sinon, une réponse complète.                                                      |
| `tools`, `tool_choice`                                               | Non         | Déclaration et sélection des outils. Votre application exécute les fonctions clientes.                                      |
| `parallel_tool_calls`, `max_tool_calls`                              | Non         | Parallélisme des outils et limites d’appels, lorsque ces options sont prises en charge.                                     |
| `include`                                                            | Non         | Champs supplémentaires dans la réponse, par exemple `reasoning.encrypted_content`.                                          |
| `metadata`, `store`                                                  | Non         | Métadonnées et préférence de stockage des réponses.                                                                         |
| `previous_response_id`                                               | Non         | Identifiant d’une réponse antérieure, uniquement tant qu’elle reste disponible auprès du fournisseur qui traite la requête. |
| `truncation`                                                         | Non         | Politique de troncature des entrées.                                                                                        |
| `prompt_cache_key`, `prompt_cache_retention`, `prompt_cache_options` | Non         | Routage et durée de conservation du cache, lorsque le canal les prend en charge.                                            |
| `reasoning.mode`, `reasoning.context`                                | Non         | Transmis au fournisseur ; les restrictions propres au modèle s’appliquent. Omettez-les sauf si votre workflow les exige.    |
| `context_management`, `conversation`, `prompt`                       | Non         | Paramètres natifs de contexte ou de prompt stocké, lorsque le fournisseur les prend en charge.                              |

## Raisonnement et outils [#raisonnement-et-outils]

Luna accepte les requêtes sans raisonnement avec `none`. Chat Completions ne prend en charge l’appel de fonctions qu’avec `reasoning_effort: "none"` ; utilisez Responses pour combiner outils et raisonnement.

Omettez `temperature`, `top_p` et `top_logprobs` lorsque le raisonnement est activé. Pour Chat Completions, omettez aussi `logprobs` ; pour Responses, ne demandez pas `message.output_text.logprobs` dans `include`.

Le budget de sortie couvre à la fois le raisonnement et le texte visible. La limite de sortie peut être atteinte avant qu’une réponse complète soit produite. Un effort plus élevé peut consommer davantage de tokens de sortie et prendre plus de temps.

Pour une sortie structurée, utilisez `text.format` avec `type: "json_schema"`, un nom et un schéma pris en charge par le modèle. Le schéma contraint la structure, pas l’exactitude des faits. Pour poursuivre une conversation avec des outils, renvoyez les résultats des fonctions clientes avec l’identifiant de l’appel d’origine.

## Périmètre actuel de l’API [#périmètre-actuel-de-lapi]

La passerelle accepte `POST /v1/responses` et `POST /v1/chat/completions`. La disponibilité des modèles dépend des canaux configurés ; consultez `GET /v1/models` avec authentification avant l’intégration. L’absence de tarifs ci-dessous ne permet pas de conclure qu’un modèle est prêt à recevoir des appels.

La couche de compatibilité transmet les champs reconnus, pas du JSON arbitraire. Le DTO Responses actuel n’inclut pas les champs natifs `access_programs`, `image` ou `background`. Ne supposez pas qu’un champ ignoré a été appliqué. Les paramètres du canal peuvent aussi filtrer `service_tier` et `safety_identifier`.

Cette intégration ne fournit ni API Files, ni API Batch, ni suivi par interrogation des réponses en arrière-plan. Utilisez des réponses synchrones ou SSE. Les outils intégrés dépendent de leur disponibilité chez le fournisseur et peuvent entraîner des frais distincts ; déclarer un outil ne garantit pas qu’une session complète avec cet outil soit disponible ici.

## Images en entrée [#images-en-entrée]

Utilisez l’URL HTTP(S) publiquement accessible d’une image que vous hébergez. Placez l’image et la question dans un élément d’entrée utilisateur :

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

Remplacez l’URL d’exemple par celle de votre image. Cette intégration ne fournit aucun service de téléversement ni de stockage des médias.

## 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-luna",
    "messages": [{"role":"user","content":"Explain what a database index does."}],
    "reasoning_effort": "low",
    "max_completion_tokens": 1024
  }'
```

Lisez `choices[0].message.content`. Chat Completions utilise `messages`, `reasoning_effort` et `max_completion_tokens` ; Responses utilise `input`, `reasoning.effort` et `max_output_tokens`. Pour les messages contenant des images dans Chat Completions, utilisez `type: "image_url"` et `image_url: {"url":"https://..."}`.

## Tarifs [#tarifs]

USD par million de tokens

Les tarifs actuels incluent le coefficient de chaque groupe. Ils sont mis en cache pendant 2 minutes au maximum.

Une seule clé API donne accès à tous les modèles et groupes. La mention « Par défaut » désigne le premier groupe éligible dans l’ordre du routage automatique ; la requête est facturée aux tarifs du groupe effectivement sélectionné.

### GPT Luna 6

`gpt-6-luna`

| Tokens facturables | gpt · Par défaut · ≤ 272 000 tokens d’entrée | gpt · Par défaut · > 272 000 tokens d’entrée | gpt-0.7 · ≤ 272 000 tokens d’entrée | gpt-0.7 · > 272 000 tokens d’entrée |
| --- | ---: | ---: | ---: | ---: |
| Entrée (hors cache) | 0,01 $US | 0,02 $US | 0,07 $US | 0,14 $US |
| Sortie | 0,05 $US | 0,075 $US | 0,35 $US | 0,525 $US |
| Lecture du cache | 0,001 $US | 0,002 $US | 0,007 $US | 0,014 $US |
| Écriture du cache | 0,0125 $US | 0,025 $US | 0,0875 $US | 0,175 $US |

Le seuil porte sur : Total des tokens d’entrée, y compris ceux en cache. Le palier sélectionné s’applique à toute la requête, pas seulement aux tokens au-delà du seuil.

— signifie qu’aucun tarif vérifié n’est disponible ; cela ne signifie pas que le service est gratuit.

Les tarifs du cache s’appliquent uniquement lorsque la réponse indique l’usage correspondant. Ne comptez pas à nouveau les tokens en cache comme des tokens d’entrée hors cache.

Multipliez le nombre de tokens de chaque catégorie facturable par le tarif correspondant, puis divisez par 1 000 000. Le raisonnement est inclus dans les tokens de sortie et n’est pas facturé une seconde fois. Les entrées en cache ne doivent pas aussi être comptées comme des entrées hors cache. Utilisez uniquement l’usage du cache indiqué par la réponse ; l’unité d’écriture du cache dans le tableau ne signifie pas que tous les modes de conservation sont pris en charge.

Pour les tarifs selon la longueur, le palier applicable couvre toute la requête. Consultez le seuil du tableau et la base de calcul des entrées plutôt que de supposer un tarif fixe. Les requêtes sans en-tête de groupe utilisent `gpt`. Pour choisir un groupe avec Responses ou Chat Completions, envoyez `X-Model-Group: gpt` ou `X-Model-Group: gpt-0.7`. `gpt-0.7` est disponible uniquement pour Luna, Sol et Astra ; Terra prend uniquement en charge `gpt`. Une sélection explicite ne bascule jamais vers un autre groupe. Ne modifiez pas l’identifiant du modèle ; les suffixes de groupe ne sont pas pris en charge.

## Réponses et streaming [#réponses-et-streaming]

Un résultat Responses terminé contient `id`, `model`, `status`, `output` et `usage`. `output` peut contenir du raisonnement, des appels d’outils et des messages ; ne supposez pas que son premier élément est du texte. Le raccourci `output_text` du SDK OpenAI rassemble le texte de sortie.

Définissez `stream: true` et utilisez `curl -N` pour SSE. Gérez `response.created`, `response.output_text.delta`, `response.completed`, les réponses incomplètes et les erreurs. La réponse finale contient les données d’usage. Chat Completions diffuse `choices[].delta` ; demandez `stream_options: {"include_usage":true}` pour recevoir les données d’usage dans le dernier fragment.

## Journaux d’usage et erreurs [#journaux-dusage-et-erreurs]

Les [journaux LLM](/fr/usage) affichent les appels terminés des 7 derniers jours avec le modèle, les tokens d’entrée, les tokens de sortie et le coût. Filtrez par `gpt-6-luna`. Pour les images et vidéos, consultez les [journaux des tâches](/fr/tasks).

En cas d’échec, examinez le statut HTTP et l’objet `error`. Vérifiez votre clé, votre [solde](/fr/docs/balance), l’identifiant exact du modèle et la combinaison de paramètres. Si une requête ou un flux est interrompu, consultez les journaux avant de réessayer : une nouvelle requête peut entraîner de nouveaux frais.

## Références du modèle [#références-du-modèle]

* [Spécification officielle de GPT Luna 6](https://developers.openai.com/api/docs/models/gpt-6-luna)
* [Référence de Responses](https://developers.openai.com/api/reference/resources/responses/methods/create)
* [Modèles GPT et raisonnement](https://developers.openai.com/api/docs/guides/latest-model)
