Blog

Tutoriel

Comment utiliser gpt-6-sol via l'API HiAPI : curl, Python et une requête qui fonctionne

Nov 12, 2026
Illustration de couverture architecturale avec des plans de béton gris chaud traversés par une ombre inclinée bleu ardoise et une fine ligne vert sauge.
Sur cette page

Ce qu'il faut préparer avant le premier appel

Avant d'écrire la moindre ligne de code, préparez trois choses. Le reste de ce tutoriel repose sur cette base.

Une clé d'API HiAPI

Chaque requête envoyée à l'API HiAPI doit être authentifiée avec une clé d'API. Créez une clé dans le tableau de bord de votre compte HiAPI et conservez-la en lieu sûr, de préférence dans une variable d'environnement plutôt que dans un fichier source. Traitez-la comme un mot de passe : dès qu'elle est compromise, faites-la tourner immédiatement.

export HIAPI_API_KEY="your-api-key-here"

Le point de terminaison de base

Tous les appels de ce guide sont envoyés au point de terminaison de base de l'API HiAPI, et chaque modèle est accessible via la même forme de chemin de requête. Vous n'avez pas besoin d'un hôte ni d'un SDK distinct par modèle — gpt-6-sol se choisit dans le corps de la requête, et non en modifiant la configuration du client.

Un client HTTP

Vous avez besoin de l'un des éléments suivants :

  • curl, disponible par défaut sur la plupart des systèmes Linux et macOS ainsi que dans le terminal Windows.
  • Python avec la bibliothèque requests installée (pip install requests), ou la bibliothèque standard urllib si vous préférez éviter les dépendances.

Aucun autre outil n'est nécessaire. Vous n'avez besoin ni d'un SDK propre à un fournisseur, ni d'installer quoi que ce soit lié au modèle. Il suffit de pouvoir envoyer une requête POST HTTPS avec un corps JSON et des en-têtes pour appeler gpt-6-sol.

Une habitude à prendre dès maintenant : conservez un fichier brouillon contenant la requête qui fonctionne, afin qu'en cas d'échec vous puissiez comparer l'appel défaillant avec le dernier appel connu comme fonctionnel.

S'authentifier avec une clé bearer

L'authentification est la source d'erreur la plus fréquente lors du premier appel ; elle mérite donc une attention particulière.

L'en-tête Authorization

L'API HiAPI attend votre clé dans l'en-tête bearer standard :

Authorization: Bearer $HIAPI_API_KEY

Il s'agit du mot littéral Bearer, d'un espace, puis de la clé. Les erreurs courantes incluent : oublier le mot Bearer, inclure un saut de ligne superflu lors du copier-coller de la valeur, ou entourer la clé de guillemets alors que le client en ajoute déjà.

Le type de contenu doit être JSON

La requête transporte un corps JSON, donc l'en-tête de type de contenu doit correspondre :

Content-Type: application/json

Si cet en-tête est absent, certains serveurs analysent quand même le corps, mais ne comptez pas là-dessus — définissez-le explicitement. Une incohérence de type de contenu est une cause fréquente d'erreurs de validation de requête qui ressemblent à des erreurs de corps.

L'ensemble minimal d'en-têtes

Vous n'avez besoin que des deux en-têtes ci-dessus :

Authorization: Bearer $HIAPI_API_KEY
Content-Type: application/json

Gardez l'ensemble d'en-têtes aussi réduit que possible. Les en-têtes spéculatifs empruntés à d'autres exemples d'API risquent davantage de semer la confusion que d'aider. Une fois qu'un appel avec ces deux en-têtes réussit, vous disposez d'une base propre pour comparer plus tard.

Évitez de coller la clé directement dans l'historique du shell ou dans un fichier commité. Référencer la variable d'environnement comme ci-dessus garde la clé hors de votre code source et de l'historique du terminal.

Construire le corps de la requête pour gpt-6-sol

Le corps de la requête est du JSON, et son cœur est une liste de messages. Commencez par la configuration minimale ; n'ajoutez des champs qu'une fois l'appel réussi.

La charge utile minimale

Le corps de requête minimal utile doit spécifier le modèle et fournir un message :

{
  "model": "gpt-6-sol",
  "messages": [
    { "role": "user", "content": "Explique en une phrase ce qu'est un jeton bearer d'API." }
  ]
}

Deux champs entrent en jeu ici :

  • model sélectionne gpt-6-sol, de sorte que le même point de terminaison puisse plus tard servir d'autres modèles.
  • messages est la liste ordonnée des tours de conversation. Chaque entrée possède un role (system, user ou assistant) et un content de type chaîne.

Valeurs par défaut sûres et ajouts facultatifs

Considérez model et messages comme obligatoires. Tout le reste est facultatif et doit être ajouté délibérément :

  • Un message system placé en tête de messages définit le comportement ou le ton de la conversation. C'est un message ordinaire, et non un champ racine séparé.
  • Si nécessaire, le contrôle de la longueur de sortie se règle via des paramètres du corps de requête. Ajoutez-les uniquement si la sortie par défaut est trop courte ou trop longue pour votre cas d'usage.
  • Les paramètres d'échantillonnage modifient la forme de la sortie, pas sa validité. Évitez de les modifier lors du débogage d'un appel en échec, car ils ne corrigent ni les erreurs d'authentification ni les erreurs de structure du corps.

Une règle pratique

En cas d'échec, la charge utile doit rester aussi proche que possible de l'exemple minimal. Retirez les champs facultatifs un par un jusqu'à ce que l'appel réussisse, puis réajoutez-les. Cela permet d'isoler rapidement le problème : un mauvais paramètre est plus facile à trouver qu'un mauvais paramètre enfoui parmi cinq bons.

Envoyer une requête qui fonctionne avec curl

Voici une commande complète que vous pouvez exécuter directement, à condition d'avoir exporté votre clé. Elle utilise un chemin de point de terminaison fictif conforme aux conventions de l'API HiAPI décrites ci-dessus.

curl -sS -X POST "$HIAPI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-sol",
    "messages": [
      { "role": "user", "content": "Explique en une phrase ce qu'est un jeton bearer d'API." }
    ]
  }'

Définissez HIAPI_BASE_URL comme le point de terminaison de base indiqué dans votre tableau de bord HiAPI. Les options sont importantes :

  • -X POST définit la méthode ; ces appels sont tous des POST.
  • -H ajoute chaque en-tête, un par ligne.
  • -d fournit le corps JSON. Les guillemets simples empêchent l'interprétation par le shell.
  • -sS garde la sortie silencieuse mais affiche tout de même les erreurs, ce qui est exactement ce qu'il faut en scripting.

Lire la réponse

Une réponse réussie est du JSON. Vous verrez généralement un objet racine contenant le nom du modèle et une liste choices, chaque choice ayant un message dont le content contient le texte généré. Lisez d'abord la structure, puis le contenu : vérifiez que l'objet s'analyse correctement, puis localisez le champ content.

Pour améliorer la lisibilité, vous pouvez rediriger vers un formateur JSON :

... | python -m json.tool

Si votre terminal affiche à la place un objet d'erreur, l'appel n'a pas réussi — passez à la section sur les erreurs plutôt que de modifier le prompt. Lorsque la requête n'atteint pas du tout le modèle, le problème ne vient pas du prompt.

Envoyer la même requête avec Python

La charge utile que vous venez de valider avec curl se transpose directement. Gardez le corps strictement identique, afin que les correctifs validés dans le terminal s'appliquent également dans le code.

import os
import requests

api_key = os.environ["HIAPI_API_KEY"]
base_url = os.environ["HIAPI_BASE_URL"]

payload = {
    "model": "gpt-6-sol",
    "messages": [
        {"role": "user", "content": "Explique en une phrase ce qu'est un jeton bearer d'API."}
    ],
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

response = requests.post(
    f"{base_url}/chat/completions",
    headers=headers,
    json=payload,
    timeout=60,
)

response.raise_for_status()
data = response.json()

for choice in data.get("choices", []):
    message = choice.get("message", {})
    print(message.get("content", ""))

Pourquoi cette version est plus sûre dans le code applicatif

  • Le corps est un dictionnaire. Lorsque vous passez json=payload, requests le sérialise et définit le type de contenu pour vous, mais conserver des en-têtes explicites évite les surprises lors d'un changement de client.
  • La clé provient d'une variable d'environnement. Aucun secret n'est codé en dur, ce fichier peut donc être commité.
  • raise_for_status() s'exécute en premier. Une réponse non-2xx lève immédiatement une exception, avant que vous ne tentiez de lire des champs inexistants dans le corps d'une réponse d'erreur.
  • Un délai d'expiration est défini. Sans délai, une connexion bloquée peut suspendre indéfiniment un processus de travail.

La boucle qui parcourt choices prémunit également contre les clés manquantes, ce qui rend l'exemple tolérant aux réponses contenant peu ou pas de sortie. Construisez votre encapsulage de production autour de ce squelette : valider, envoyer, vérifier le statut, puis analyser.

Recevoir la réponse en streaming plutôt que d'attendre

Par défaut, l'API renvoie la réponse complète dans une seule réponse JSON. Pour les sorties longues ou les interfaces interactives, vous pouvez demander que la réponse soit livrée progressivement au fur et à mesure de sa génération.

L'interrupteur de streaming

Le streaming s'active par un indicateur dans le corps de la requête, et non via un point de terminaison différent :

{
  "model": "gpt-6-sol",
  "messages": [
    { "role": "user", "content": "Écris un court texte sur les codes de statut HTTP." }
  ],
  "stream": true
}

Ajoutez cet indicateur en dernier, une fois qu'un appel non-streaming fonctionne déjà. Il modifie l'organisation de la réponse, pas la validité de la requête.

Consommer la sortie incrémentale

Avec le streaming activé, la réponse n'est plus un document JSON unique. Elle arrive sous forme d'une série d'événements, généralement séparés par des lignes, chaque événement portant un petit fragment de sortie. Votre client doit les lire à leur arrivée, plutôt que d'appeler .json() sur l'ensemble du corps de la réponse.

with requests.post(
    f"{base_url}/chat/completions",
    headers=headers,
    json=payload,
    stream=True,
    timeout=60,
) as response:
    response.raise_for_status()
    for line in response.iter_lines():
        if line:
            print(line.decode("utf-8"))

Dans le terminal, ce même indicateur se comporte différemment d'un appel non-streaming : la sortie apparaît progressivement, si bien qu'un pipeline interrompu peut ressembler à une requête échouée alors que le flux a simplement été coupé.

Lequel choisir

Utilisez le non-streaming pour les tâches par lots, les tests et tout cas où vous avez besoin de l'objet complet d'un coup. Utilisez le streaming lorsqu'une personne attend le texte ou que la sortie est suffisamment longue pour que la latence soit perceptible. Conservez les deux chemins dans votre base de code, car le chemin non-streaming est plus facile à déboguer.

Lire et corriger les codes d'erreur courants

Diagnostiquez d'abord par le code de statut, puis par le corps de la réponse. Ne changez pas de modèle et ne réécrivez pas le prompt avant d'avoir identifié la couche qui échoue.

401 Unauthorized

Cause : clé absente, mal formatée ou révoquée.Correctif : vérifiez que l'en-tête est exactement Authorization: Bearer <key>, recherchez des espaces invisibles ou une variable d'environnement obsolète, et confirmez que la clé est toujours valide dans votre tableau de bord. Affichez la longueur de la variable plutôt que sa valeur pour détecter les variables vides.

400 Bad Request

Cause : le corps de la requête ne peut pas être analysé ou il manque des champs obligatoires.Correctif : renvoyez la charge utile minimale, contenant uniquement model et messages. Validez le JSON avec python -m json.tool avant l'envoi ; une virgule finale ou une faute de frappe dans model sont des causes courantes. Confirmez que Content-Type vaut application/json.

403 Forbidden

Cause : la clé est valide, mais elle n'a pas accès à la ressource demandée.Correctif : vérifiez que votre compte a accès à gpt-6-sol et que le nom du modèle dans le corps de la requête correspond à ce qui est configuré pour votre compte.

404 Not Found

Cause : chemin d'URL incorrect, souvent une faute de frappe dans le point de terminaison, ou un chemin de base manquant ou dupliqué.Correctif : comparez l'URL complète caractère par caractère avec l'appel curl qui fonctionne.

429 Too Many Requests

Cause : vous envoyez des requêtes plus vite que ne le permet votre compte.Correctif : attendez et réessayez avec un délai croissant. Respectez les indications de réessai présentes dans les en-têtes de réponse, et ne réessayez jamais en boucle serrée — cela aggraverait le problème. Distinguez cela des erreurs 5xx, qui indiquent un problème côté serveur et non lié à votre débit de requêtes.

Erreurs serveur 5xx

Cause : le service ne parvient pas à traiter une requête pourtant valide.Correctif : réessayez avec un délai croissant ; si le problème persiste, capturez le corps de la réponse et l'ID de requête, et évitez de modifier la charge utile puisqu'elle fonctionnait.

Un ordre de débogage reproductible

  1. Code de statut — s'agit-il d'un problème d'authentification, de chemin ou de corps de requête ?
  2. Corps de la réponse — indique-t-il le champ en cause ?
  3. Structure de la charge utile — revenez à l'exemple minimal.
  4. Le prompt ou les paramètres en dernier lieu.

Cet ordre raccourcit durablement le délai entre l'échec et le correctif. Une fois vos appels stabilisés, conservez côte à côte les versions curl et Python qui fonctionnent, afin que chaque futur test parte d'un état connu comme fonctionnel.

Articles similaires

Voir tous les articles →

Commencez avec des artefacts IA persistants

Obtenez votre clé API et appelez des modèles d'image, de vidéo et d'audio via une API unique basée sur les tasks.

Lire la documentation de l'API