Moderering av innehåll med API:t
På denna sida
Uppdaterat den 3 november 2026 baserat på OpenAIs guide för Moderation: kategorierna
illicitochillicit/violentför modellenomni-moderation-latestsaknades i listan och koden. Källa: Moderation.
Moderering av innehåll med API:t
OpenAIs Moderations-API upptäcker automatiskt olämpligt innehåll. Det är ett kostnadsfritt och oumbärligt verktyg för alla applikationer som accepterar användargenererat innehåll. Föregående lektion visade dig hur du skriver egna filter; denna ger dig en tränad klassificerare som fångar det som reguljära uttryck aldrig hittar – dolda hot, indirekta förolämpningar och implicita formuleringar.
Moderations-API:t
Anropet är avsiktligt minimalt: en modell, en text och ett resultat som kokas ner till ett booleskt värde. Fältet flagged svarar på den binära frågan: “Bryter detta innehåll mot användningsvillkoren?”, medan categories specificerar vilka. Eftersom denna endpoint är gratis finns det ingen ekonomisk anledning att hoppa över den, ens vid höga volymer.
from openai import OpenAI
client = OpenAI()
# The Moderation API is FREE
moderation = client.moderations.create(
model="omni-moderation-latest",
input="Hello, how are you?"
)
result = moderation.results[0]
print(f"Content flagged: {result.flagged}")
print(f"Categories: {result.categories}")
# Result:
# Content flagged: False
# Categories: Categories(harassment=False, hate=False, ...)
Modereringskategorier
Bakom det booleska värdet döljer sig ett finmaskigt rutnät. Modellen returnerar ett beslut per kategori – trakasserier, hotfulla trakasserier, hat, hotfullt hat, instruktioner för olagliga handlingar (med eller utan våld), självskada med dess varianter (instruktioner och avsikt), sexuellt innehåll, sexuellt innehåll som involverar minderåriga, våld och grafiskt våld – tillsammans med en konfidenspoäng mellan 0,0 och 1,0 för var och en.
Dessa poäng är viktigare än det binära beslutet när du vill kalibrera din policy. En professionell forumplattform kan vilja blockera vid 0,3 för trakasserier, medan en tjänst för skönlitteratur kan acceptera 0,7 för våld. Funktionen nedan exponerar båda insiktsnivåerna: de kategorier som faktiskt utlösts och de råa poängen för dina egna tröskelvärden.
def analyze_moderation(text: str) -> dict:
"""Detailed moderation analysis."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
# Available categories
categories = {
"harassment": result.categories.harassment,
"harassment_threatening": result.categories.harassment_threatening,
"hate": result.categories.hate,
"hate_threatening": result.categories.hate_threatening,
"illicit": result.categories.illicit,
"illicit_violent": result.categories.illicit_violent,
"self_harm": result.categories.self_harm,
"self_harm_instructions": result.categories.self_harm_instructions,
"self_harm_intent": result.categories.self_harm_intent,
"sexual": result.categories.sexual,
"sexual_minors": result.categories.sexual_minors,
"violence": result.categories.violence,
"violence_graphic": result.categories.violence_graphic,
}
# Confidence scores (0.0 to 1.0)
scores = {
"harassment": result.category_scores.harassment,
"hate": result.category_scores.hate,
"self_harm": result.category_scores.self_harm,
"sexual": result.category_scores.sexual,
"violence": result.category_scores.violence,
}
return {
"flagged": result.flagged,
"detected_categories": [k for k, v in categories.items() if v],
"main_scores": {k: round(v, 4) for k, v in scores.items()},
}
# Test
result = analyze_moderation("Hello everyone!")
print(f"Flagged: {result['flagged']}")
print(f"Scores: {result['main_scores']}")
Kompletta modereringsflöden
Moderering av användarinmatning
Låt oss paketera detta anrop i en återanvändbar komponent. ContentModerator returnerar ett explicit par – godkänt eller inte, med anledning – snarare än ett rått objekt som varje anropare måste tolka om. Att översätta kategorier till tydligt språk är avgörande: detta är ordförrådet som kommer att synas i ditt gränssnitt och dina loggar, och det måste vara begripligt för det mänskliga modereringsteam som tar över.
class ContentModerator:
"""Content moderator for applications."""
def __init__(self, custom_threshold: float = 0.5):
self.client = OpenAI()
self.threshold = custom_threshold
def moderate(self, text: str) -> tuple[bool, dict]:
"""Moderates text. Returns (is_acceptable, details)."""
moderation = self.client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
if result.flagged:
categories = []
if result.categories.harassment:
categories.append("harassment")
if result.categories.hate:
categories.append("hate speech")
if result.categories.sexual:
categories.append("sexual content")
if result.categories.violence:
categories.append("violence")
if result.categories.self_harm:
categories.append("self-harm")
return False, {
"reason": "Inappropriate content detected",
"categories": categories
}
return True, {"reason": "Content acceptable"}
def moderate_conversation(self, messages: list[str]) -> list[dict]:
"""Moderates a list of messages."""
results = []
for msg in messages:
acceptable, details = self.moderate(msg)
results.append({
"message": msg[:50] + "..." if len(msg) > 50 else msg,
"acceptable": acceptable,
**details
})
return results
# Usage
moderator = ContentModerator()
acceptable, details = moderator.moderate("Hello, how can I help you?")
print(f"Acceptable: {acceptable}")
print(f"Details: {details}")
Integration i API-flödet
Moderering ramar in anropet på båda sidor. Filtrering av inmatning undviker att du betalar för generering av innehåll du ändå skulle avvisa; filtrering av utdata skyddar mot fall där modellen, skickligt provocerad, producerar något oacceptabelt själv. Notera skillnaden i hantering: för inmatning kan du tala om för användaren vad som upptäcktes, eftersom denne skrev det; för utdata hålls meddelandet vagt, eftersom en detaljering skulle innebära att beskriva det modellen just producerat.
def moderated_chatbot(user_input: str) -> str:
"""Chatbot with moderation of both inputs AND outputs."""
moderator = ContentModerator()
# 1. Moderate input
input_ok, input_details = moderator.moderate(user_input)
if not input_ok:
return (f"Your message was blocked: "
f"{', '.join(input_details['categories'])}")
# 2. Generate response
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Respond in a professional and safe manner.",
input=user_input
)
# 3. Moderate output
output_ok, output_details = moderator.moderate(response.output_text)
if not output_ok:
return "I am unable to provide that response."
return response.output_text
# Test
print(moderated_chatbot("What is the capital of France?"))
Batch-moderering
Detta dubbla anrop lägger till latens, vilket är acceptabelt i konversation men blir förbjudande när du behöver bearbeta tiotusen kundrecensioner importerade från en fil. För att moderera stora volymer effektivt skickar du en array direkt: API:t bearbetar alla texter i en enda begäran och returnerar resultaten i samma ordning, vilket låter dig koppla ihop dem igen via index.
def moderate_batch(texts: list[str]) -> list[dict]:
"""Moderates multiple texts in a single request."""
results = []
# The API accepts an array of inputs
moderation = client.moderations.create(
model="omni-moderation-latest",
input=texts
)
for i, result in enumerate(moderation.results):
results.append({
"index": i,
"text_preview": texts[i][:50],
"flagged": result.flagged,
})
flagged_count = sum(1 for r in results if r["flagged"])
print(f"Moderated {len(texts)} texts: {flagged_count} flagged")
return results
# Usage
texts = [
"Hello, how are you?",
"Great product, I recommend it!",
"Customer service is excellent.",
]
results = moderate_batch(texts)
Loggning av moderering
Ett modereringsbeslut påverkar en användare, och förr eller senare kommer du att behöva motivera det – oavsett om det gäller en kund som bestrider en blockering eller en tillsynsmyndighet. Därför bör du systematiskt logga domen, användar-ID:t, poängen och ett textutdrag. Loggnivån skiljer mellan de två fallen: warning för flaggat innehåll, vilket förtjänar mänsklig granskning, och info för resten, vilket matar din statistik.
import json
import logging
from datetime import datetime
logger = logging.getLogger("moderation")
def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
"""Moderates and logs the result for auditing."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
log_entry = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"flagged": result.flagged,
"text_preview": text[:100],
"scores": {
"harassment": round(result.category_scores.harassment, 4),
"hate": round(result.category_scores.hate, 4),
"violence": round(result.category_scores.violence, 4),
}
}
if result.flagged:
logger.warning(json.dumps(log_entry))
else:
logger.info(json.dumps(log_entry))
return not result.flagged
# Usage
is_ok = moderate_with_log("Test message", user_id="user-123")
En sista varning innan vi går vidare: moderering klassificerar innehåll; den förstår inte avsikt. Ett helt artigt meddelande som försöker jailbreak:a din assistent kommer att passera alla dessa filter utan att flaggas en enda gång. Det är ämnet för nästa lektion.
Viktiga punkter
- Moderations-API:t är kostnadsfritt – använd det systematiskt
- Moderera både inmatning (användarinnehåll) OCH utdata (modellens svar)
- Modellen
omni-moderation-latesttäcker alla innehållskategorier - Logga alla modereringsbeslut för revision
- Använd batch-bearbetning för att moderera stora volymer effektivt
- Moderering kompletterar systeminstruktioner; den ersätter dem inte