Pourquoi utiliser l’API OpenAI ?
ChatGPT est puissant, mais limité à une interface de chat. L’API OpenAI vous permet d’intégrer l’intelligence artificielle directement dans vos applications, sites web, scripts d’automatisation et workflows. Vous pouvez créer un chatbot personnalisé pour votre entreprise, automatiser la rédaction de contenu, analyser des documents, générer des images — tout cela de manière programmatique. Ce tutoriel vous guide pas à pas de la création de votre compte à l’intégration complète dans un projet réel.
Étape 1 : Créer un compte et obtenir une clé API
1. Rendez-vous sur platform.openai.com
2. Créez un compte ou connectez-vous avec votre compte ChatGPT
3. Cliquez sur votre profil → "API Keys"
4. Cliquez sur "Create new secret key"
5. Donnez un nom à votre clé (ex: "Projet TechSenegal")
6. Copiez la clé immédiatement — elle ne sera plus affichée
Format : sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx
IMPORTANT :
- Ne partagez JAMAIS votre clé API publiquement
- Ne la mettez pas dans votre code source sur GitHub
- Stockez-la dans une variable d'environnement
Crédits et tarifs (janvier 2025) :
- GPT-3.5-turbo : ~0.50$ / 1 million de tokens (~750 000 mots)
- GPT-4o : ~2.50$ / 1M tokens en entrée, ~10$ / 1M en sortie
- GPT-4o-mini : ~0.15$ / 1M tokens en entrée (le meilleur rapport qualité-prix)
- DALL-E 3 : ~0.04$ par image (1024×1024)
- Whisper : ~0.006$ par minute d'audio
- TTS : ~15$ / 1M caractères
Un budget de 5$ permet environ 2 millions de tokens GPT-4o-mini,
soit environ 1 500 000 mots — largement suffisant pour un prototype.Étape 2 : Premier appel API en Python
# Installation
pip install openai python-dotenv
# Créez un fichier .env à la racine de votre projet
# .env
OPENAI_API_KEY=sk-proj-votre-cle-ici
# premier_appel.py
import openai
from dotenv import load_dotenv
import os
# Charger la clé API depuis le fichier .env
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# Premier appel à l'API
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": "Tu es un assistant utile qui répond en français."
},
{
"role": "user",
"content": "Explique-moi ce qu'est une API en 3 phrases simples."
}
],
temperature=0.7, # Créativité (0 = déterministe, 2 = très créatif)
max_tokens=200 # Longueur maximale de la réponse
)
# Extraire la réponse
print(response.choices[0].message.content)
print(f"
Tokens utilisés : {response.usage.total_tokens}")
print(f"Coût estimé : {response.usage.total_tokens * 0.00000015:.6f}$")
# Sortie :
# "Une API (Application Programming Interface) est un intermédiaire qui
# permet à deux logiciels de communiquer entre eux. C'est comme un serveur
# dans un restaurant : vous passez votre commande (requête), le serveur
# la transmet à la cuisine (serveur), et vous recevez votre plat (réponse).
# En programmation, les API permettent d'utiliser les fonctionnalités d'un
# service externe sans avoir à recréer tout depuis zéro."
# Tokens utilisés : 142
# Coût estimé : 0.000021$Étape 3 : Comprendre les paramètres de l’API
# Paramètres essentiels de l'API Chat Completions
response = client.chat.completions.create(
# MODÈLE — quel cerveau utiliser
model="gpt-4o-mini", # Rapide et économique
# model="gpt-4o", # Plus puissant, plus cher
# model="gpt-3.5-turbo", # Ancien, déconseillé
# MESSAGES — la conversation
messages=[
# System : définit le comportement de l'IA
{"role": "system", "content": "Tu es un expert en marketing digital au Sénégal."},
# User : le message de l'utilisateur
{"role": "user", "content": "Comment promouvoir un restaurant à Dakar ?"},
# Assistant : réponse précédente (pour le contexte multi-tour)
# {"role": "assistant", "content": "Voici mes suggestions..."},
# User : question de suivi
# {"role": "user", "content": "Et sur les réseaux sociaux ?"},
],
# TEMPERATURE — créativité de la réponse
temperature=0.7,
# 0.0 = réponse déterministe (toujours la même)
# 0.3 = factuel, précis (idéal pour extraction de données)
# 0.7 = équilibré (bon par défaut)
# 1.5 = très créatif (brainstorming, fiction)
# MAX_TOKENS — longueur max de la réponse
max_tokens=500,
# 100 tokens ≈ 75 mots en français
# 500 tokens ≈ 375 mots
# 4000 tokens ≈ 3000 mots
# TOP_P — alternative à temperature (ne pas utiliser les deux)
# top_p=0.9,
# FREQUENCY_PENALTY — pénalise la répétition de mots
frequency_penalty=0.3, # 0 à 2 (0 = pas de pénalité)
# PRESENCE_PENALTY — encourage les nouveaux sujets
presence_penalty=0.3, # 0 à 2
# STOP — arrête la génération à ces séquences
# stop=["
", "FIN"],
# N — nombre de réponses alternatives à générer
# n=3, # Génère 3 réponses différentes (facturé 3x)
)Étape 4 : Construire un chatbot contextuel
Un chatbot efficace maintient le contexte de la conversation. Voici comment implémenter une conversation multi-tours :
# chatbot.py — Chatbot conversationnel avec mémoire
import openai
from dotenv import load_dotenv
import os
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
class Chatbot:
def __init__(self, system_prompt, model="gpt-4o-mini"):
self.model = model
self.messages = [
{"role": "system", "content": system_prompt}
]
def ask(self, user_message):
"""Envoie un message et retourne la réponse"""
# Ajouter le message utilisateur à l'historique
self.messages.append({"role": "user", "content": user_message})
# Appeler l'API avec tout l'historique
response = client.chat.completions.create(
model=self.model,
messages=self.messages,
temperature=0.7,
max_tokens=500
)
# Extraire la réponse
assistant_message = response.choices[0].message.content
# Ajouter la réponse à l'historique (pour le prochain tour)
self.messages.append({"role": "assistant", "content": assistant_message})
return assistant_message
def reset(self):
"""Réinitialise la conversation (garde le system prompt)"""
self.messages = [self.messages[0]]
# Utilisation
bot = Chatbot(
system_prompt="""Tu es l'assistant commercial de WebDakar,
agence de création de sites web à Dakar.
Services : sites vitrines (500 000 FCFA), e-commerce (1 500 000 FCFA),
applications web (sur devis). Délai moyen : 4-6 semaines.
Tu réponds en français, tu es professionnel et chaleureux."""
)
# Conversation
print(bot.ask("Bonjour, combien coûte un site e-commerce ?"))
# → "Bonjour ! Notre offre site e-commerce est à 1 500 000 FCFA..."
print(bot.ask("Et si je veux aussi une application mobile ?"))
# → L'IA se souvient de la conversation précédente et répond en contexte
print(bot.ask("Quels sont les délais ?"))
# → Répond en tenant compte de tout l'historiqueÉtape 5 : Intégrer l’API dans une application web Flask
# Installation
pip install flask openai python-dotenv
# app.py — API web avec Flask
from flask import Flask, request, jsonify
from flask_cors import CORS
import openai
from dotenv import load_dotenv
import os
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
app = Flask(__name__)
CORS(app) # Permet les requêtes depuis votre frontend
# Stocker les conversations en mémoire (en production, utilisez Redis ou une BDD)
conversations = {}
@app.route('/api/chat', methods=['POST'])
def chat():
data = request.json
user_message = data.get('message')
session_id = data.get('session_id', 'default')
# Initialiser la conversation si nouvelle
if session_id not in conversations:
conversations[session_id] = [
{"role": "system", "content": """Tu es l'assistant de TechSenegal,
boutique informatique à Dakar. Tu aides les clients à choisir
le bon matériel. Tu donnes les prix en FCFA. Tu es amical."""}
]
# Ajouter le message utilisateur
conversations[session_id].append(
{"role": "user", "content": user_message}
)
# Appeler l'API OpenAI
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=conversations[session_id],
temperature=0.7,
max_tokens=500
)
assistant_message = response.choices[0].message.content
# Sauvegarder la réponse dans l'historique
conversations[session_id].append(
{"role": "assistant", "content": assistant_message}
)
return jsonify({
"response": assistant_message,
"tokens_used": response.usage.total_tokens
})
@app.route('/api/reset', methods=['POST'])
def reset():
session_id = request.json.get('session_id', 'default')
if session_id in conversations:
conversations[session_id] = [conversations[session_id][0]]
return jsonify({"status": "conversation reset"})
if __name__ == '__main__':
app.run(debug=True, port=5000)
# Lancer : python app.py
# Tester : curl -X POST http://localhost:5000/api/chat # -H "Content-Type: application/json" # -d '{"message": "Quel PC pour un étudiant ?", "session_id": "user123"}'Étape 6 : Frontend HTML/JavaScript
<!-- index.html — Interface de chat simple -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Chat TechSenegal</title>
<style>
body { font-family: 'Inter', sans-serif; max-width: 600px; margin: 50px auto; }
#chat-box { height: 400px; overflow-y: auto; border: 1px solid #ddd;
padding: 15px; border-radius: 10px; background: #f9f9f9; }
.user-msg { text-align: right; margin: 10px 0; }
.user-msg span { background: #FF6B35; color: white; padding: 8px 15px;
border-radius: 15px; display: inline-block; }
.bot-msg { text-align: left; margin: 10px 0; }
.bot-msg span { background: #e8e8e8; padding: 8px 15px;
border-radius: 15px; display: inline-block; }
#input-area { display: flex; gap: 10px; margin-top: 15px; }
#user-input { flex: 1; padding: 10px; border: 1px solid #ddd;
border-radius: 8px; font-size: 16px; }
button { padding: 10px 20px; background: #FF6B35; color: white;
border: none; border-radius: 8px; cursor: pointer; font-size: 16px; }
</style>
</head>
<body>
<h2>💬 Assistant TechSenegal</h2>
<div id="chat-box"></div>
<div id="input-area">
<input type="text" id="user-input" placeholder="Posez votre question...">
<button onclick="sendMessage()">Envoyer</button>
</div>
<script>
const chatBox = document.getElementById('chat-box');
const input = document.getElementById('user-input');
const sessionId = 'session_' + Math.random().toString(36).substr(2, 9);
async function sendMessage() {
const message = input.value.trim();
if (!message) return;
// Afficher le message utilisateur
chatBox.innerHTML += '<div class="user-msg"><span>' + message + '</span></div>';
input.value = '';
chatBox.scrollTop = chatBox.scrollHeight;
// Afficher "en cours..."
chatBox.innerHTML += '<div class="bot-msg" id="typing"><span>⏳ En cours...</span></div>';
// Appeler l'API
const response = await fetch('http://localhost:5000/api/chat', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ message, session_id: sessionId })
});
const data = await response.json();
// Remplacer "en cours" par la réponse
document.getElementById('typing').remove();
chatBox.innerHTML += '<div class="bot-msg"><span>' + data.response + '</span></div>';
chatBox.scrollTop = chatBox.scrollHeight;
}
input.addEventListener('keypress', (e) => {
if (e.key === 'Enter') sendMessage();
});
</script>
</body>
</html>Étape 7 : Autres API OpenAI utiles
Génération d’images avec DALL-E 3
# Générer une image
response = client.images.generate(
model="dall-e-3",
prompt="A modern coworking space in Dakar, Senegal, with young African "
"professionals working on laptops, natural lighting, plants, "
"contemporary African art on walls, warm colors",
size="1024x1024",
quality="standard", # "standard" ou "hd"
n=1
)
image_url = response.data[0].url
print(f"Image générée : {image_url}")
# Téléchargez l'image depuis cette URLTranscription audio avec Whisper
# Transcrire un fichier audio (conférence, interview, réunion)
audio_file = open("reunion_equipe.mp3", "rb")
transcription = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
language="fr", # Langue de l'audio
response_format="text" # ou "json", "srt" (sous-titres), "vtt"
)
print(transcription)
# → Texte complet de la transcription
# Combiner avec GPT pour résumer la réunion
summary = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Résume cette transcription de réunion en points clés et actions à suivre."},
{"role": "user", "content": transcription}
]
)
print(summary.choices[0].message.content)Text-to-Speech (synthèse vocale)
# Convertir du texte en audio
response = client.audio.speech.create(
model="tts-1", # ou "tts-1-hd" pour meilleure qualité
voice="nova", # alloy, echo, fable, onyx, nova, shimmer
input="Bienvenue chez TechSenegal, votre partenaire informatique à Dakar. "
"Comment puis-je vous aider aujourd'hui ?"
)
# Sauvegarder le fichier audio
response.stream_to_file("bienvenue.mp3")Bonnes pratiques et sécurité
Protégez votre clé API. Utilisez des variables d’environnement (.env), jamais de clé en dur dans le code. En production, utilisez un gestionnaire de secrets (AWS Secrets Manager, Azure Key Vault, ou Doppler). Si votre clé est compromise, régénérez-la immédiatement depuis platform.openai.com.
Limitez les coûts. Configurez un budget mensuel dans votre dashboard OpenAI (Settings → Billing → Usage limits). Commencez avec un plafond bas (10$) et augmentez progressivement. Surveillez votre consommation quotidiennement pendant la phase de développement.
Gérez les erreurs. L’API peut renvoyer des erreurs (rate limiting, timeout, clé invalide). Implémentez des retries avec backoff exponentiel et des messages d’erreur clairs pour vos utilisateurs. La bibliothèque openai gère déjà les retries basiques, mais ajoutez votre propre logique pour les cas complexes.
Optimisez les tokens. Chaque token coûte de l’argent. Réduisez la taille du system prompt, limitez l’historique de conversation (gardez les 10 derniers messages), et utilisez max_tokens pour éviter les réponses trop longues. GPT-4o-mini offre un excellent rapport qualité-prix pour la majorité des cas d’usage.
