Comment appeler gpt-6-luna via l'API hiapi : curl, Python et requêtes exécutables

TL;DR

• C'est quoi : le tout dernier modèle textuel économique d'OpenAI, conçu pour le traitement par lots et les scénarios à haut débit. Déjà disponible sur HiAPI, ouvrez la page du modèle pour discuter directement, 200 crédits offerts à l'inscription des nouveaux utilisateurs.
• Combien ça coûte : facturation au token, palier standard entrée $0,025/M, sortie $0,125/M, cache hit $0,0025/M, c'est le modèle GPT textuel le moins cher sur HiAPI.
• Comment appeler l'API : le protocole par défaut est l'API Responses (POST /v1/responses), Chat Completions (POST /v1/chat/completions) est également pris en charge. Contexte de 1,05 M, sortie maximale de 128 K.
• Paramètres clés : six niveaux de raisonnement reasoning.effort (none/low/medium/high/xhigh/max), temperature, top_p, text.format (json_schema).

Le GPT-6 Luna vient de sortir, et les deux questions les plus fréquentes sont : comment l'appeler, et en quoi il diffère de Chat Completions. Toutes les réponses sont dans cet article.

Que peut faire GPT-6 Luna ?

• Classification de textes en masse. Analyse d'avis produits, classification de tickets, étiquetage de contenus : à $0,025/M en entrée, traiter cent mille lignes ne coûte presque rien.
• Extraction de données structurées. Extraire du JSON à partir de textes non structurés, en définissant directement text.format avec json_schema pour contraindre la sortie.
• Réécriture et mise en forme de contenus. Réduction de similarité d'articles, polissage multilingue, uniformisation de format : un seul prompt lancé en masse suffit.
• Réponses automatiques aux FAQ. Questions-réponses client à faible complexité : définissez reasoning.effort=none pour désactiver le raisonnement, c'est rapide et économique.
• Boucles d'agents simples. Appel d'outils + dialogue multi-tours, adapté aux processus d'automatisation qui ne nécessitent pas de raisonnement profond.

Deux parcours de prise en main : essai en ligne ou API ?

Pour d'abord voir le résultat, choisissez l'essai en ligne ; pour intégrer dans un produit, choisissez l'API. Les deux voies utilisent le même modèle et la même grille tarifaire.

Essai en ligne (environ 1 minute)

1. Ouvrez la page du modèle GPT-6 Luna.
2. Inscrivez-vous ou connectez-vous, un nouveau compte bénéficie de 200 crédits.
3. Saisissez directement votre prompt, ajustez les paramètres dans le Playground pour voir le résultat.

Intégration API (environ 5 minutes)

1. Créez une API Key (sk-...) dans la console HiAPI.
2. POST /v1/responses pour l'API Responses (par défaut) ou POST /v1/chat/completions pour Chat Completions.
3. Le résultat se trouve dans output.

Premier appel : version curl (API Responses, recommandée)

curl -s https://api.hiapi.ai/v1/responses \
  -H "Authorization: Bearer sk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": [
      {"role": "user", "content": "Présente HiAPI en une phrase, réponds en français."}
    ]
  }'

Voici un exemple de réponse, la réponse se trouve dans output[0].content[0].text :

{
  "id": "resp_...",
  "model": "gpt-6-luna",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "HiAPI est une plateforme intermédiaire API qui agrège plusieurs modèles d'IA..."
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 25,
    "output_tokens": 32,
    "total_tokens": 57
  }
}

Cet appel consomme 57 tokens, soit environ $0,0056 au palier standard : presque rien.

Premier appel : version Python (API Responses)

import requests

API = "https://api.hiapi.ai/v1/responses"
HEADERS = {
    "Authorization": "Bearer sk-YOUR_KEY",
    "Content-Type": "application/json"
}

payload = {
    "model": "gpt-6-luna",
    "input": [
        {"role": "user", "content": "Présente HiAPI en une phrase, réponds en français."}
    ]
}

resp = requests.post(API, headers=HEADERS, json=payload, timeout=60)
data = resp.json()
text = data["output"][0]["content"][0]["text"]
usage = data["usage"]
print(f"Réponse : {text}")
print(f"Consommation : {usage['total_tokens']} tokens (entrée {usage['input_tokens']} + sortie {usage['output_tokens']})")

Forcer une sortie structurée avec json_schema

C'est l'usage central de Luna dans les scénarios d'extraction en masse. Définissez text.format sur json_schema, définissez name et schema, et la sortie du modèle respectera strictement la structure JSON que vous avez spécifiée :

curl -s https://api.hiapi.ai/v1/responses \
  -H "Authorization: Bearer sk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": [
      {
        "role": "user",
        "content": "Avis produit : la couleur est jolie, mais le fond s'est décollé après deux semaines. Je ne recommande pas."
      }
    ],
    "text": {
      "format": {
        "type": "json_schema",
        "name": "review_analysis",
        "schema": {
          "type": "object",
          "properties": {
            "sentiment": {"type": "string", "enum": ["positive", "neutral", "negative"]},
            "pros": {"type": "array", "items": {"type": "string"}},
            "cons": {"type": "array", "items": {"type": "string"}},
            "recommend": {"type": "boolean"}
          },
          "required": ["sentiment", "pros", "cons", "recommend"]
        }
      }
    }
  }'

Le modèle renvoie un JSON conforme au schema, sans analyse manuelle nécessaire.

Interface alternative Chat Completions

Si votre code existant utilise déjà le protocole Chat Completions, il suffit de changer de modèle :

curl -s https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "messages": [
      {"role": "user", "content": "Présente HiAPI en une phrase, réponds en français."}
    ]
  }'

L'API Responses est recommandée par défaut : le format d'entrée est un tableau input, et elle prend en charge la configuration reasoning et la sortie structurée text.format. Chat Completions ne prend pas en charge max_completion_tokens et max_tokens (Luna, sous ces deux protocoles, ne passe que par le format input).

Paramètres clés

Paramètre	Obligatoire	Description
model	Oui	gpt-6-luna
input	Oui	Tableau de messages, chacun contenant role et content
reasoning.effort	Non	Intensité du raisonnement, six niveaux : none/low/medium(par défaut)/high/xhigh/max
temperature	Non	Contrôle l'aléatoire, ajustable lorsque reasoning.effort=none
top_p	Non	Échantillonnage nucleus, ajustable lorsque reasoning.effort=none
text.format	Non	Contrôle du format de sortie, prend en charge json_schema et strict
max_output_tokens	Non	Nombre maximal de tokens en sortie
tools	Non	Définition des outils, pour les scénarios d'agents
tool_choice	Non	Stratégie de sélection des outils

À propos de l'utilisation de reasoning.effort :

• none : désactive le raisonnement, adapté à la classification, l'extraction, les questions-réponses simples. À ce moment, temperature et top_p peuvent être ajustés librement.
• low/medium (par défaut) : raisonnement léger à modéré, adapté aux questions-réponses générales et à la génération de contenu.
• high/xhigh/max : raisonnement approfondi, pour les analyses complexes. Attention : plus le niveau est élevé, plus la consommation de tokens de raisonnement augmente.

Pour les tâches en masse, définissez none ; pour les conversations quotidiennes, medium par défaut suffit ; pour les analyses complexes, augmentez selon les besoins.

Erreurs courantes

• 400 model not found → faute de frappe dans le champ model → vérifiez qu'il s'agit bien de gpt-6-luna.
• 400 additional properties not allowed → un champ non pris en charge a été transmis (comme max_tokens de Chat Completions) → retirez les champs superflus.
• 401 permission_denied → Key manquante ou incorrecte → vérifiez Authorization: Bearer sk-....
• 400 json_schema validation failed → définition du schema non conforme → vérifiez le tableau required et le type de chaque champ dans properties.

Questions fréquentes

API Responses ou Chat Completions, lequel choisir ? Pour une nouvelle intégration, utilisez l'API Responses. Elle prend en charge l'entrée en tableau input, reasoning.effort, la sortie json_schema via text.format et d'autres nouvelles fonctionnalités. Si vous avez déjà du code Chat Completions et ne voulez pas le modifier, il suffit de changer de modèle.

Quelle différence entre reasoning.effort=none et désactiver le raisonnement ? Après avoir défini none, le modèle ne produit pas de tokens de raisonnement ; la sortie ne contient que le texte de réponse final. À ce moment, temperature et top_p peuvent être ajustés manuellement. Pour la classification, l'extraction et la mise en forme, none suffit : moins de tokens et plus rapide.

Comment fonctionne le cache ? Il s'active automatiquement. Les parties répétées dans le prompt système et l'historique de conversation touchent le cache et sont facturées à $0,0025/M. Aucune configuration supplémentaire n'est nécessaire.

Comment passer par Batch pour les tâches en masse ? Ajoutez "processing_mode": "batch" dans la requête ; la tâche entre dans une file asynchrone, avec un tarif réduit de 50 %. Adapté aux tâches qui n'exigent pas de réponse en temps réel.

Quels changements par rapport à gpt-5.6-luna ? Prix divisé par deux (entrée $0,025 vs $0,05), sortie 2,4 fois moins chère, ajout de l'API Responses comme protocole par défaut, six niveaux de raisonnement (exactement identiques à 6-luna, les six niveaux sont disponibles), contexte passé à 1,05 M. Voir comparaison GPT-6 Luna vs GPT-5.6 Luna.

Articles de la série GPT-6 Luna

• Page du modèle GPT-6 Luna : dialogue en ligne, 200 crédits offerts à l'inscription
• Tarifs de l'API GPT-6 Luna : $0,025/M en entrée, le GPT le moins cher de HiAPI
• GPT-6 Luna vs GPT-5.6 Luna : prix divisé par deux, faut-il changer
• Exemples de prompts GPT-6 Luna : 5 scénarios en masse à copier directement

Essayez maintenant : copiez la commande curl ci-dessus, remplacez par votre API Key et réussissez votre premier appel. Ou ouvrez la page du modèle pour discuter directement en ligne.