API de modération d'OpenAI
Šajā lapā
Mis à jour le 3 novembre 2026 sur la base du guide Moderation d’OpenAI : ajout de la catégorie
illicit(etillicit/violent), qui manquait dans le tableau, ainsi que des catégories applicables aux images. Source : Moderation.
Un outil de modération intégré
OpenAI propose une API de modération gratuite qui analyse le texte pour détecter les contenus potentiellement nocifs. C’est la première ligne de défense à intégrer dans toute application utilisant les modèles OpenAI, et tu n’es pas limité à ce seul cas d’usage : puisqu’elle accepte du texte brut en entrée, tu peux aussi l’utiliser pour filtrer des entrées destinées à d’autres modèles. Le fait qu’elle soit gratuite change ta façon d’aborder le problème. Les arbitrages habituels — devons-nous modérer chaque requête ou seulement les suspectes ? — perdent de leur poids, car le seul coût restant est la latence.
Ce que renvoie l’API
L’appel de base tient en une ligne ; c’est la réponse qui demande attention. L’API renvoie trois éléments distincts : un booléen flagged reflétant la décision d’OpenAI, la liste des catégories effectivement déclenchées et, surtout, des scores continus par catégorie. Ce sont ces scores qui font la différence en production, car ils te permettent de décider toi-même où placer la limite plutôt que d’hériter d’un seuil conçu pour un usage générique.
from openai import OpenAI
client = OpenAI()
def moderate_content(text: str) -> dict:
"""Analyse le texte via l'API de modération d'OpenAI."""
response = client.moderations.create(input=text)
result = response.results[0]
return {
"blocked": result.flagged,
"categories": {
cat: flagged
for cat, flagged in result.categories.__dict__.items()
if flagged
},
"scores": {
cat: round(score, 4)
for cat, score in result.category_scores.__dict__.items()
if score > 0.01
},
}
# Test avec différents types de contenu
examples = [
"How do I bake a chocolate cake?",
"I will kill you if you don't answer me",
"Explain how AES encryption works",
]
for text in examples:
result = moderate_content(text)
status = "BLOCKED" if result["blocked"] else "OK"
print(f"{status} : {text[:50]}...")
if result["categories"]:
print(f" Categories : {list(result['categories'].keys())}")
Les trois exemples de test ne sont pas aléatoires : le premier devrait passer, le second devrait être bloqué, et le troisième — une question technique parfaitement légitime — te montre comment ton pipeline se comporte face à un vocabulaire lié à la sécurité. C’est exactement le genre de requête qu’une équipe de cybersécurité traite quotidiennement.
Catégories détectées
L’API classe les contenus problématiques selon plusieurs axes, chacun correspondant à un type de préjudice distinct.
| Category | Description |
|---|---|
| harassment | Harcèlement, menaces, intimidation |
| hate | Discours de haine basé sur l'identité |
| illicit | Conseils ou instructions pour commettre des actes illicites |
| self-harm | Automutilation, suicide |
| sexual | Contenu sexuel explicite |
| violence | Violence graphique, menaces |
Chaque catégorie dispose également de sous-catégories (par exemple harassment/threatening, illicit/violent, violence/graphic) pour un filtrage plus fin. Avec omni-moderation-latest, seules self-harm et ses variantes, sexual, et violence (avec violence/graphic) s’appliquent aussi aux images ; les autres catégories ne concernent que le texte. Cette granularité t’évite de faire des arbitrages grossiers : une plateforme de modération de forum pourrait vouloir bloquer harassment/threatening tout en tolérant le simple harassment, qui couvre de nombreux conflits ordinaires.
Lorsque tu dois traiter du volume — une analyse rétrospective d’un historique de conversation, par exemple — l’API accepte une liste et renvoie un résultat pour chaque élément, évitant ainsi plusieurs allers-retours réseau.
def moderate_batch(messages: list[str]) -> list[dict]:
"""Modère plusieurs messages en un seul appel."""
response = client.moderations.create(input=messages)
results = []
for i, result in enumerate(response.results):
results.append({
"index": i,
"text": messages[i][:50],
"blocked": result.flagged,
"max_score": max(
score
for score in result.category_scores.__dict__.values()
),
})
return results
Modérer les deux extrémités du pipeline
Une erreur courante consiste à modérer uniquement les entrées. Cela repose sur une intuition fausse : si le message entrant est acceptable, la réponse le sera aussi. Pourtant, un modèle peut produire un contenu problématique à partir d’une requête neutre, surtout lorsqu’il s’appuie sur des documents récupérés dont personne n’a vérifié le contenu. La classe ci-dessous applique donc le même traitement dans les deux sens, en ajoutant un seuil personnalisé qui renforce la décision par défaut de l’API.
class ModerationPipeline:
"""Pipeline de modération entrée + sortie pour une application LLM."""
def __init__(self, custom_threshold: float = 0.7):
self.client = OpenAI()
self.threshold = custom_threshold
def moderate_input(self, message: str) -> tuple[bool, dict]:
"""Modère le message AVANT l'envoi au modèle."""
result = self.client.moderations.create(input=message).results[0]
scores = result.category_scores.__dict__
high_categories = {
cat: score for cat, score in scores.items() if score > self.threshold
}
blocked = result.flagged or bool(high_categories)
return blocked, {"flagged_api": result.flagged, "custom_categories": high_categories}
def moderate_output(self, response: str) -> tuple[bool, dict]:
"""Modère la réponse du modèle AVANT l'envoi à l'utilisateur."""
return self.moderate_input(response)
def process_message(self, user_message: str, system_prompt: str) -> str:
"""Pipeline complet : modération entrée, LLM, modération sortie."""
# Étape 1 : modérer l'entrée
input_blocked, details = self.moderate_input(user_message)
if input_blocked:
return "Votre message ne peut pas être traité. Veuillez le reformuler."
# Étape 2 : appeler le modèle
response = self.client.chat.completions.create(
model="gpt-5.6-sol",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_message},
],
)
model_response = response.choices[0].message.content
# Étape 3 : modérer la sortie
output_blocked, _ = self.moderate_output(model_response)
if output_blocked:
return "La réponse a été filtrée pour non-conformité."
return model_response
# Utilisation
pipeline = ModerationPipeline(custom_threshold=0.5)
response = pipeline.process_message(
"How do I protect my application against SQL injections?",
"You are an expert in defensive cybersecurity."
)
print(response)
Ce que cette API ne fait pas
Sa limitation la plus importante est aussi la plus mal comprise : elle ne détecte pas l’injection de prompt. Un message poli, parfaitement inoffensif du point de vue du contenu, mais qui demande au modèle d’ignorer ses instructions, passera sans déclencher aucune catégorie. S’attendre à ce qu’elle protège contre la manipulation revient à installer un détecteur de fumée en espérant qu’il arrête les cambrioleurs.
Les faux positifs constituent la deuxième limitation, particulièrement sensible dans les contextes de sécurité ou médicaux, où décrire une menace fait partie du métier. Un appel réseau supplémentaire s’ajoute à chaque requête, ce qui compte lorsque tu vises des réponses en temps réel. La détection reste plus fiable en anglais que dans d’autres langues, un angle mort que les attaquants connaissent parfaitement. Enfin, les catégories et les seuils évoluent avec les mises à jour : un jeu de calibration établi il y a six mois mérite une revérification.
Ces limites dictent la façon d’utiliser l’outil. Modère dans les deux sens, ajuste les seuils catégorie par catégorie plutôt que globalement, et combine-la systématiquement avec d’autres couches — détection d’injection, filtrage par logique métier — que les leçons suivantes détaillent. Journalise les résultats, car observer tes propres faux positifs est la façon d’apprendre où déplacer les curseurs. Et prévois le cas où l’API serait indisponible : décide maintenant, tandis que les choses sont calmes, si ton application doit bloquer par défaut ou laisser passer le trafic, plutôt que de découvrir ce comportement lors d’un incident.
Galvenās atziņas
- L’API de modération est gratuite, rapide et simple à intégrer
- Elle détecte les contenus offensifs, mais pas les injections ni les jailbreaks
- Le pipeline entrée-modèle-sortie doit être modéré aux deux extrémités
- Les seuils par défaut correspondent rarement à tes besoins — adapte-les à ton contexte
- C’est une couche parmi d’autres, jamais la seule ligne de défense