Votre premier appel API

L’environnement est prêt : passons à la pratique. Vous allez effectuer votre premier appel à la Responses API, disséquer l’objet qu’elle retourne, puis manipuler les paramètres qui font la différence entre une réponse quelconque et une réponse utile.

L’appel le plus simple

Deux paramètres suffisent : model, l’identifiant du modèle à solliciter, et input, votre prompt — un texte, ou une liste de messages comme nous le verrons plus loin.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Quelle est la différence entre Python et JavaScript ?"
)

print(response.output_text)
# Résultat : Python est un langage polyvalent orienté vers la science des
# données et le backend, tandis que JavaScript est principalement utilisé
# pour le développement web frontend et backend (via Node.js)...

Ce que contient vraiment la réponse

output_text n’est qu’un raccourci de lecture. L’objet response transporte aussi son identifiant — indispensable pour chaîner les échanges et pour retrouver un appel dans vos journaux —, le modèle effectivement utilisé, et le détail de la consommation. Prenez l’habitude de logger ces trois informations dès vos premiers scripts : c’est ce qui vous permettra plus tard de répondre à la question « pourquoi la facture a-t-elle doublé ce mois-ci ».

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Bonjour, comment allez-vous ?"
)

# Le texte de la réponse (raccourci)
print(response.output_text)

# L'identifiant unique de la réponse
print(f"ID : {response.id}")

# Le modèle utilisé
print(f"Modèle : {response.model}")

# Les tokens consommés
print(f"Tokens entrée : {response.usage.input_tokens}")
print(f"Tokens sortie : {response.usage.output_tokens}")
print(f"Tokens total : {response.usage.total_tokens}")

# Résultat :
# Bonjour ! Je vais très bien, merci. Comment puis-je vous aider ?
# ID : resp_abc123xyz
# Modèle : gpt-5.6-terra
# Tokens entrée : 14
# Tokens sortie : 19
# Tokens total : 33

Les paramètres qui comptent

La temperature gouverne la variabilité de la génération. À 0.0, le modèle choisit systématiquement la continuation la plus probable : c’est le réglage des questions factuelles, des extractions de données et de tout ce que vous voudrez pouvoir rejouer à l’identique. À 1.0, il explore davantage, ce que vous recherchez pour du naming, de la rédaction créative ou de la génération de variantes.

# Température basse (0.0) = déterministe, factuel
response_factuel = client.responses.create(
    model="gpt-5.6-terra",
    input="Quelle est la capitale de l'Allemagne ?",
    temperature=0.0
)
print(response_factuel.output_text)
# Résultat : La capitale de l'Allemagne est Berlin.

# Température haute (1.0) = créatif, varié
response_creatif = client.responses.create(
    model="gpt-5.6-terra",
    input="Inventez un nom pour un café littéraire.",
    temperature=1.0
)
print(response_creatif.output_text)
# Résultat : "Les Pages Vagabondes" — un café où chaque table porte
# le nom d'un chapitre célèbre.

Le paramètre instructions remplit le rôle de l’ancien message système : il définit le rôle, le ton et les contraintes que le modèle doit conserver pendant tout l’échange, indépendamment de la question posée. Dans l’exemple ci-dessous, la même question posée sans instructions produirait une liste de conseils généraux ; avec elles, elle produit des recettes.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Vous êtes un expert en cuisine française. "
                 "Répondez toujours avec des suggestions de recettes.",
    input="Je ne sais pas quoi faire avec des courgettes."
)
print(response.output_text)
# Résultat : Voici trois idées pour vos courgettes :
# 1. Gratin de courgettes au fromage de chèvre...
# 2. Ratatouille provençale...
# 3. Velouté froid de courgettes à la menthe...

max_output_tokens plafonne enfin la longueur de la réponse. C’est un garde-fou budgétaire, pas une consigne de rédaction : la réponse est coupée net une fois la limite atteinte. Si vous voulez une réponse courte et bien formée, demandez-le aussi dans le prompt.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Expliquez la relativité générale.",
    max_output_tokens=100
)
print(response.output_text)
print(f"Tokens utilisés : {response.usage.output_tokens}")
# La réponse sera tronquée à environ 100 tokens

Passer à un input structuré

Quand une simple chaîne ne suffit plus, input accepte une liste de messages. La forme minimale contient un seul tour, mais l’intérêt apparaît dès que vous fournissez un historique : le modèle dispose alors de ce qui a déjà été dit et répond en conséquence, comme ici où « progresser » se comprend en Python et non dans l’absolu.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "Traduisez en anglais : Bonjour le monde"
        }
    ]
)
print(response.output_text)
# Résultat : Hello world

# Avec un contexte de conversation
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "Mon langage préféré est Python."
        },
        {
            "role": "assistant",
            "content": "Python est un excellent choix ! Il est très polyvalent."
        },
        {
            "role": "user",
            "content": "Donnez-moi un conseil pour progresser."
        }
    ]
)
print(response.output_text)
# Résultat : Pour progresser en Python, je vous recommande de...

Ne laissez jamais un appel sans filet

Un appel réseau échoue, et une clé expire. Trois exceptions couvrent l’essentiel des cas au démarrage : AuthenticationError pour une clé absente ou invalide, RateLimitError quand vous dépassez votre débit autorisé, et APIError comme filet générique. Une leçon entière reviendra sur la stratégie complète, mais dès aujourd’hui, entourez vos appels.

from openai import OpenAI, APIError, AuthenticationError, RateLimitError

client = OpenAI()

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="Bonjour !"
    )
    print(response.output_text)
except AuthenticationError:
    print("Erreur : clé API invalide ou manquante")
except RateLimitError:
    print("Erreur : trop de requêtes, attendez un moment")
except APIError as e:
    print(f"Erreur API : {e.message}")

Pour consolider tout cela, écrivez un script qui pose trois questions et cumule les tokens consommés. Vous y combinerez la boucle d’appels, la température à 0.0 pour des réponses stables et la lecture de usage — les trois réflexes de base.

from openai import OpenAI

client = OpenAI()

questions = [
    "Quel est le plus grand océan du monde ?",
    "Qui a peint la Joconde ?",
    "Combien de planètes compte le système solaire ?"
]

total_tokens = 0

for question in questions:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=question,
        temperature=0.0
    )
    tokens = response.usage.total_tokens
    total_tokens += tokens
    print(f"Q: {question}")
    print(f"R: {response.output_text}")
    print(f"   ({tokens} tokens)\n")

print(f"Total : {total_tokens} tokens consommés")

Points clés à retenir

Un appel basique nécessite seulement model et input
response.output_text donne le texte de la réponse
response.usage détaille la consommation de tokens
La temperature contrôle la créativité (0.0 = factuel, 1.0 = créatif)
Les instructions remplacent le message système de Chat Completions
Gérez toujours les erreurs avec des blocs try/except