Moderación y seguridad de contenido visual
En esta página
- Moderación y seguridad de contenido visual
- El sistema de moderación integrado
- Prefiltrado de prompts
- Comprueba también las imágenes generadas
- Cuando los usuarios escriben los prompts
- Registro para rendición de cuentas
- Derechos de autor y marcas registradas
- Cumplimiento del RGPD
- Antes de abrir las compuertas
- Pon a prueba tus conocimientos
Actualizado el 3 de noviembre de 2026 según la guía de Generación de imágenes de OpenAI: un rechazo por moderación se identifica mediante
error.code == "moderation_blocked", con un objeto opcionalmoderation_details, no por la presencia de las palabrassafetyocontent_policyen el mensaje de error; se ha añadido el parámetromoderation(auto,low). Fuente: Generación de imágenes.
Actualización del 2 de noviembre de 2026 — Modelos de imagen.
gpt-image-1, sobre el que se escribió originalmente este curso, se discontinuó el 23 de octubre de 2026, ygpt-image-1.5,gpt-image-1-miniychatgpt-image-latestse retirarán el 1 de diciembre de 2026. Los ejemplos ahora usangpt-image-2.5-sunburst, el más preciso para edición;gpt-image-2.5-flarees más rápido para generación estándar. Ambos aceptan también las calidadesxhighymax. Los modelos GPT Image devuelven siempre la imagen en base64: el parámetroresponse_formatde los modelos DALL·E anteriores no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).
Moderación y seguridad de contenido visual
Mientras generes imágenes para ti mismo, la moderación es una cuestión de criterio personal. En cuanto abras la generación a usuarios, se convierte en una responsabilidad legal y ética que te vincula. Esta lección cubre las herramientas de moderación de OpenAI, cómo encadenarlas en filtros sucesivos y las medidas que protegen tanto a tu aplicación como a las personas que la utilizan.
El sistema de moderación integrado
GPT Image rechaza por sí solo cierto contenido —violencia, material sexualmente explícito, entre otros— y señala este rechazo con un error específico. Tu código debe, por tanto, distinguir un rechazo por política de contenido de un fallo técnico, porque ambos exigen reacciones opuestas: el primero deriva en un mensaje al usuario, el segundo en una alerta a tu equipo. La documentación de OpenAI especifica el discriminador a usar: un rechazo por moderación llega como un BadRequestError con error.code igual a moderation_blocked (tipo image_generation_user_error), y el cuerpo del error puede contener un objeto moderation_details que especifica la etapa (input, output o unknown) y categorías generales (harassment, sexual, violence…). No busques palabras en el mensaje de error: su texto no es un contrato, el código sí lo es. La función siguiente vuelve a lanzar la excepción solo si no se trata de un rechazo por moderación.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Genera una imagen gestionando los rechazos por moderación."""
try:
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
import base64
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
return {"status": "ok", "path": output}
except BadRequestError as e:
if e.code != "moderation_blocked":
raise # fallo técnico, cuota, solicitud inválida: gestionar elsewhere
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Content refused by safety policy",
"stage": details.get("moderation_stage"), # input, output o unknown
"categories": details.get("categories") or [], # para tus registros
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI aconseja mantener un mensaje genérico para el usuario final y reservar moderation_details para tus registros y soporte. Estos errores no se resuelven reintentando: sin modificar el prompt o las imágenes proporcionadas, la misma solicitud será rechazada de nuevo. Observa finalmente que la severidad del filtrado se establece mediante el parámetro moderation de los modelos GPT Image: auto (filtrado estándar, por defecto) o low (menos restrictivo).
Prefiltrado de prompts
Esperar a que GPT Image rechace un prompt para descubrir que era problemático es insatisfactorio: ya has consumido la llamada a la API y no aprendes nada específico sobre el motivo. La API de Moderación, en cambio, es gratuita, rápida y devuelve categorías nombradas. Llamarla antes de la generación te permite rechazar limpiamente, explicar al usuario qué se ha marcado y conservar esta información para tu auditoría. La función verify_prompt extrae la lista de categorías activadas, y generate_safe_image simplemente encadena los dos pasos: comprobar primero, generar después.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Comprueba un prompt con la API de Moderación antes de la generación."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=prompt
)
result = moderation.results[0]
if result.flagged:
categories_flagged = [
cat for cat, flagged in result.categories.__dict__.items()
if flagged
]
return {
"allowed": False,
"categories": categories_flagged,
"message": "This prompt was flagged by the moderation system."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pipeline completo: moderación + generación."""
# Paso 1: prefiltrado
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt refused: {check['message']}")
print(f"Categories: {check['categories']}")
return None
# Paso 2: generación
print("Prompt validated, generating...")
return generate_with_moderation(prompt, output)
# Prueba con un prompt inofensivo
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Comprueba también las imágenes generadas
Un prompt inocente puede dar lugar a una imagen que no lo sea. Una formulación retorcida, la ambigüedad de un término o simplemente una interpretación desafortunada del modelo bastan para producir contenido visual que no querrías mostrar bajo tu logotipo. El modelo omni-moderation-latest acepta imágenes como entrada, lo que te permite cerrar el ciclo: la misma mecánica de categorías se aplica al archivo generado. El pipeline completo siguiente encadena las tres fases —comprobación del prompt, generación, comprobación de la imagen— y, crucialmente, en caso de marcaje, elimina el archivo del disco antes de devolver su veredicto. Una imagen problemática dejada en el servidor «mientras miramos» es una imagen que posiblemente se filtrará.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analiza una imagen generada para detectar contenido problemático."""
with open(image_path, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
moderation = client.moderations.create(
model="omni-moderation-latest",
input=[
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
)
result = moderation.results[0]
if result.flagged:
categories_flagged = [
cat for cat, flagged in result.categories.__dict__.items()
if flagged
]
return {
"safe": False,
"categories": categories_flagged
}
return {"safe": True}
def secure_pipeline(prompt: str, output: str):
"""Pipeline completo: moderación de prompt + generación + moderación de imagen."""
# 1. Comprobar el prompt
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Generar la imagen
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
# 3. Comprobar la imagen generada
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Generated image was flagged",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Cuando los usuarios escriben los prompts
El contenido generado por usuarios cambia la naturaleza del problema: ya no te enfrentas a torpezas, sino, a veces, a intentos deliberados de elusión. La clase PromptModerator apila cuatro defensas de distinta naturaleza, que es el propio principio de una protección seria. La limpieza elimina caracteres de control a través de los cuales transitan inyecciones y limita la longitud a quinientos caracteres, cortando de raíz prompts de inundación diseñados para ahogar instrucciones. La verificación local mediante una lista de palabras prohibidas —dejada vacía, para que la rellenes según tu política y sector— intercepta a coste cero lo que ya conoces. La API de Moderación se hace cargo entonces de todo lo que tu lista no anticipó. Finalmente, el prefijo de seguridad concatenado antes del prompt final recuerda explícitamente al modelo el marco esperado, desplazando el límite a tu favor en casos límite.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Filtro multicapa para prompts de usuario."""
def __init__(self):
self.forbidden_words = [] # Rellenar según tu política
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Limpia y normaliza un prompt de usuario."""
# Eliminar posibles inyecciones
prompt = prompt.strip()
# Limitar longitud
prompt = prompt[:500]
# Eliminar caracteres de control
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Comprueba la ausencia de palabras prohibidas."""
prompt_lower = prompt.lower()
for word in self.forbidden_words:
if word in prompt_lower:
return False
return True
def secure(self, prompt: str) -> str:
"""Añade un prefijo de seguridad al prompt."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Pipeline de moderación completo para un prompt de usuario."""
# Paso 1: limpieza
prompt = self.clean(raw_prompt)
# Paso 2: verificación local
if not self.check_words(prompt):
return {"allowed": False, "reason": "Forbidden word detected"}
# Paso 3: moderación por API
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Paso 4: añadir prefijo de seguridad
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simular un prompt de usuario
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Secure prompt: {result['prompt']}")
else:
print(f"Refused: {result['reason']}")
Registro para rendición de cuentas
El día que resurja una imagen problemática, la pregunta que te harán será: quién la solicitó, cuándo y qué hizo tu sistema. Sin registros, no tienes respuesta. AuditLogger escribe una línea JSON por generación en un archivo .jsonl —un formato de solo anexado que soporta escritura concurrente y puede leerse línea a línea sin cargar todo en memoria—. Cada entrada vincula un ID de usuario a un prompt truncado, el resultado de la generación y, si corresponde, el motivo del rechazo. El método report deriva entonces la tasa de aceptación de las últimas cien generaciones y detalla los rechazos: este es el panel que te alertará si una cuenta concreta acumula marcajes.
import json
import os
from datetime import datetime
class AuditLogger:
"""Registro de auditoría para generaciones de imágenes."""
def __init__(self, log_file: str = "audit_images.jsonl"):
self.log_file = log_file
def log(
self,
prompt: str,
user_id: str,
result: str,
image_path: str = None,
refusal_reason: str = None
):
"""Registra una entrada de auditoría."""
entry = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"prompt": prompt[:200],
"result": result, # "ok", "prompt_refused", "image_deleted"
"image_path": image_path,
"refusal_reason": refusal_reason,
}
with open(self.log_file, "a") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
def report(self, last_n: int = 100):
"""Genera un informe de generaciones recientes."""
if not os.path.exists(self.log_file):
print("No logs found.")
return
entries = []
with open(self.log_file, "r") as f:
for line in f:
entries.append(json.loads(line))
recent = entries[-last_n:]
total = len(recent)
ok = sum(1 for e in recent if e["result"] == "ok")
refused = sum(1 for e in recent if e["result"] != "ok")
print(f"Report of last {total} generations:")
print(f" Accepted: {ok} ({100*ok/total:.1f}%)")
print(f" Refused : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nRefusal details:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Derechos de autor y marcas registradas
GPT Image sabe producir imágenes que evocan el estilo de un artista o la identidad visual de una marca, y esta capacidad es exactamente lo que te expone. La moderación técnica no te protege en este terreno: no detecta que un póster se parezca mucho al de un competidor. La protección es, por tanto, contractual y organizativa, tomando la forma de una política de uso escrita y ejecutable que tus usuarios aceptan y tu equipo aplica. El bloque PRODUCTION_RULES da la formulación mínima, para mostrar en tu documentación así como recordar en tus condiciones.
# Mejores prácticas para integrar en tu política de uso
PRODUCTION_RULES = """
1. Do not request imitation of a living artist's style by name
2. Do not reproduce logos or registered trademarks
3. Do not generate faces of real people
4. Add an "AI-generated image" notice when required
5. Retain generation logs for at least 12 months
6. Allow users to report problematic content
"""
def usage_warning():
"""Muestra las reglas de uso en producción."""
print("=" * 60)
print("PRODUCTION RULES — AI Image Generation")
print("=" * 60)
print(PRODUCTION_RULES)
Cumplimiento del RGPD
Para una empresa europea, los plazos de retención y el consentimiento no son opciones de configuración, sino obligaciones cuyo respeto debe ser demostrable. Registrarlas en un objeto de configuración explícito, en lugar de dispersarlas por el código, te da un único lugar que mostrar durante una auditoría. ComplianceConfig fija así la retención de registros en un año, la de imágenes en noventa días, y hace obligatorio el aviso de IA y el consentimiento. El método add_ai_metadata merece atención especial: escribe en el propio PNG, vía PngInfo, el hecho de que la imagen es generada, la herramienta que la produjo y la fecha. Estos metadatos viajan con el archivo, incluso fuera de tu plataforma, algo que ningún aviso mostrado en una página web logra.
class ComplianceConfig:
"""Configuración de cumplimiento para generación de imágenes."""
def __init__(self):
self.log_retention_days = 365
self.image_retention_days = 90
self.ai_notice_mandatory = True
self.consent_required = True
def verify_consent(self, user_id: str) -> bool:
"""Verifica que el usuario ha consentido la generación con IA."""
# Implementar con tu sistema de gestión de consentimiento
return True
def add_ai_metadata(self, image_path: str):
"""Añade metadatos indicando generación con IA."""
from PIL import Image
from PIL.PngImagePlugin import PngInfo
img = Image.open(image_path)
metadata = PngInfo()
metadata.add_text("AI-Generated", "true")
metadata.add_text("Generator", "GPT Image via OpenAI API")
metadata.add_text("Date", datetime.now().isoformat())
img.save(image_path, pnginfo=metadata)
print(f"AI metadata added: {image_path}")
Antes de abrir las compuertas
Ocho disposiciones deben estar en su lugar el día que tu sistema sea accesible, y es más honesto exigirlas antes que después. Moderación primero, en sus dos fases: prefiltrado de prompts y postverificación de imágenes, como hace secure_pipeline. Registro después, completo, asociando cada generación a su prompt, autor y resultado —esta es tu única prueba en caso de disputa, y debe guardarse independientemente de las propias imágenes, de lo contrario una purga de almacenamiento se llevaría consigo tu trazabilidad—.
Luego viene la parte del usuario. Un límite de tasa por cuenta evita que un único suscriptor consuma tu presupuesto mensual en una noche, voluntariamente o mediante un script mal escrito. La información sobre la naturaleza generada de las imágenes atañe tanto a la equidad como, cada vez más, a la restricción regulatoria; se duplica con un marcado técnico en los metadatos PNG o EXIF del archivo. El derecho al borrado asume que puedes encontrar y eliminar todos los datos de un usuario bajo simple solicitud, lo cual solo es posible si tus entradas de auditoría llevan un user_id. Finalmente, abre un canal de reporte: tus usuarios verán siempre lo problemático antes que tú, y quitarles los medios para decírtelo no hace desaparecer el problema.
Ahora ensambla todo en un único servicio de generación de imágenes: prefiltrado de prompts vía API de Moderación y lista de palabras, prefijo de seguridad, postverificación de la imagen producida, registro de auditoría y metadatos de IA en cada archivo. Pruébalo con cinco prompts variados, al menos uno de los cuales debe ser rechazado —esta es la única forma de verificar que tus barreras de seguridad funcionan realmente y no solo están presentes en el código—.
Pon a prueba tus conocimientos
Generación visual vía API: valida reflejos antes de la producción.
1. ¿Qué permiten el inpainting y el outpainting?
Respuesta: El inpainting modifica un área específica de una imagen existente (reemplazar, corregir); el outpainting extiende la imagen más allá de su marco original —dos ediciones dirigidas sin regenerarlo todo—.
2. ¿Qué hace bueno a un prompt visual avanzado?
Respuesta: Describe sujeto, composición, iluminación y perspectiva, no solo el tema: cuanto más enmarque el prompt la escena como un director de fotografía, más obedecerá la imagen.
3. ¿Cómo trabajar eficazmente por iteraciones?
Respuesta: Empieza con una generación base, luego solicita variaciones dirigidas (estilo, encuadre, detalle) en lugar de reescribir el prompt desde cero —mantén lo que funciona, ajusta solo la diferencia—.
4. ¿Qué palancas usar para optimizar costes de generación?
Respuesta: Adapta calidad y resolución a la necesidad real (borradores en baja, finales en alta), limita iteraciones con mejores prompts y almacena en caché/reutiliza visuales validados.
5. ¿Por qué es esencial la moderación de contenido visual?
Respuesta: Porque la API y tus condiciones imponen límites (contenido prohibido, personas reales, marcas): filtrar prompts y controlar salidas protege a tus usuarios y a tu aplicación.
Enmarca, itera, domina costes y cumplimiento: la producción visual es un pipeline, no un tiro al azar.