Content Moderation for Images & Video

User-generated content needs a check before it reaches other users, and reviewing every upload by hand does not scale. Rekognition's moderation operations give you an automated first pass over images and video, flagging categories of unsafe or inappropriate content with confidence scores.

The pattern splits the same way the rest of Rekognition does: images are synchronous, video is an asynchronous job. This page covers both, plus how to turn the output into a review workflow instead of a blunt auto-reject.

Recipe

Quick-reference recipe card - copy-paste ready.

# --- Python (boto3) ---
import boto3
 
rekognition = boto3.client("rekognition")
with open("upload.jpg", "rb") as f:
    response = rekognition.detect_moderation_labels(
        Image={"Bytes": f.read()},
        MinConfidence=60,
    )
for label in response["ModerationLabels"]:
    print(label["Name"], label["ParentName"], label["Confidence"])

// --- TypeScript (AWS SDK v3) ---
import { RekognitionClient, DetectModerationLabelsCommand } from "@aws-sdk/client-rekognition";
import { readFileSync } from "node:fs";
 
const rekognition = new RekognitionClient({});
const response = await rekognition.send(new DetectModerationLabelsCommand({
  Image: { Bytes: readFileSync("upload.jpg") },
  MinConfidence: 60,
}));
for (const label of response.ModerationLabels ?? []) {
  console.log(label.Name, label.ParentName, label.Confidence);
}

When to reach for this:

• Screening user-uploaded photos or avatars before publishing them.
• Pre-filtering video uploads on a content platform before they go live.
• Routing flagged content to a human moderation queue instead of blocking or approving automatically.
• Building an audit trail of moderation decisions for compliance.

Working Example

Moderate an image synchronously, then kick off async moderation on a stored video and poll it to completion, reading timestamped labels along the way.

# --- Python (boto3) ---
import time
import boto3
 
rekognition = boto3.client("rekognition")
 
# Image: synchronous
with open("upload.jpg", "rb") as f:
    image_result = rekognition.detect_moderation_labels(
        Image={"Bytes": f.read()}, MinConfidence=60,
    )
flagged = image_result["ModerationLabels"]
print("image flags:", [l["Name"] for l in flagged])
 
# Video: asynchronous - start the job
start = rekognition.start_content_moderation(
    Video={"S3Object": {"Bucket": "my-bucket", "Name": "uploads/clip.mp4"}},
    MinConfidence=60,
    NotificationChannel={
        "SNSTopicArn": "arn:aws:sns:us-east-1:123456789012:rekognition-jobs",
        "RoleArn": "arn:aws:iam::123456789012:role/RekognitionSNSRole",
    },
)
job_id = start["JobId"]
 
# Poll until finished (in production, react to the SNS notification instead)
while True:
    result = rekognition.get_content_moderation(JobId=job_id)
    if result["JobStatus"] in ("SUCCEEDED", "FAILED"):
        break
    time.sleep(5)
 
if result["JobStatus"] == "SUCCEEDED":
    for item in result["ModerationLabels"]:
        label = item["ModerationLabel"]
        print(f"{item['Timestamp']}ms: {label['Name']} ({label['Confidence']:.1f})")

// --- TypeScript (AWS SDK v3) ---
import {
  RekognitionClient,
  DetectModerationLabelsCommand,
  StartContentModerationCommand,
  GetContentModerationCommand,
} from "@aws-sdk/client-rekognition";
import { readFileSync } from "node:fs";
 
const rekognition = new RekognitionClient({});
 
// Image: synchronous
const imageResult = await rekognition.send(new DetectModerationLabelsCommand({
  Image: { Bytes: readFileSync("upload.jpg") },
  MinConfidence: 60,
}));
console.log("image flags:", (imageResult.ModerationLabels ?? []).map((l) => l.Name));
 
// Video: asynchronous - start the job
const start = await rekognition.send(new StartContentModerationCommand({
  Video: { S3Object: { Bucket: "my-bucket", Name: "uploads/clip.mp4" } },
  MinConfidence: 60,
  NotificationChannel: {
    SNSTopicArn: "arn:aws:sns:us-east-1:123456789012:rekognition-jobs",
    RoleArn: "arn:aws:iam::123456789012:role/RekognitionSNSRole",
  },
}));
const jobId = start.JobId!;
 
// Poll until finished (in production, react to the SNS notification instead)
let result;
while (true) {
  result = await rekognition.send(new GetContentModerationCommand({ JobId: jobId }));
  if (result.JobStatus === "SUCCEEDED" || result.JobStatus === "FAILED") break;
  await new Promise((r) => setTimeout(r, 5000));
}
 
if (result.JobStatus === "SUCCEEDED") {
  for (const item of result.ModerationLabels ?? []) {
    console.log(`${item.Timestamp}ms: ${item.ModerationLabel?.Name} (${item.ModerationLabel?.Confidence?.toFixed(1)})`);
  }
}

What this demonstrates:

• The image path is one call, in and out, with results immediately available.
• The video path always requires StartContentModeration plus a NotificationChannel, then polling GetContentModeration for JobStatus.
• Video moderation results carry a Timestamp per label, so you can jump to the flagged moment instead of scrubbing the whole clip.
• Both paths use the same MinConfidence parameter and the same two-level Name/ParentName label taxonomy.

Deep Dive

The Moderation Label Taxonomy

Moderation labels are hierarchical: a broad category (ParentName, such as "Explicit Nudity" or "Violence") contains more specific labels (Name, such as a particular type within that category). Filtering or alerting on the parent category catches everything beneath it without enumerating every specific label.

Why Video Moderation Is Always Async

A video can run for hours, so there is no synchronous "moderate this video" call - moderation, like every other video operation, follows the start/poll pattern. StartContentModeration requires the video to already be in S3 (not sent as bytes) and takes an optional NotificationChannel (an SNS topic plus an IAM role Rekognition assumes to publish to it) so you can react to completion by event instead of polling in a loop.

Turning Flags into a Workflow, Not a Gate

The most reliable pattern uses three bands based on confidence: below a low bar, auto-approve; above a high bar, auto-reject or block; in between, route to human review. Where those bars sit is a product and legal decision, not a technical default - treat MinConfidence as the first filter, not the whole policy. Log every decision, including auto-approvals, so you can audit false negatives later.

Combining with General Labels

DetectModerationLabels is purpose-built for safety categories; it will not tell you the image also contains a "Dog" or a "Beach". If you need both moderation and general tagging, call DetectLabels alongside it - they are separate operations with separate pricing, run on the same image.

Gotchas

• Treating an empty ModerationLabels list as "safe." It only means nothing crossed MinConfidence - it is not a certified-safe guarantee. Fix: pick a MinConfidence deliberately and pair automated results with spot-check review.
• Sending video bytes directly to StartContentModeration. Video operations only accept a Video.S3Object reference, never raw bytes. Fix: upload the video to S3 first.
• Forgetting the NotificationChannel's IAM role. The role Rekognition assumes to publish to your SNS topic needs a trust policy allowing the Rekognition service principal. Fix: set up the role once per account before wiring notifications.
• Polling GetContentModeration in a tight loop. It works but wastes calls and adds latency versus reacting to the SNS notification. Fix: use NotificationChannel and trigger your poll (or final read) from the event instead.
• Auto-rejecting on any non-empty ModerationLabels. A single low-confidence label near the parent category boundary can cause over-blocking. Fix: use a review band around your threshold instead of a hard cutoff.
• Assuming moderation covers text content in the image. Moderation labels are about visual content categories, not any embedded text. Fix: pair with DetectText and your own text-moderation logic if written content matters too.

Alternatives

FAQs

Related

• Rekognition Basics - the first DetectModerationLabels call.
• Video Analysis with Asynchronous Operations - the start/poll pattern shared by every video operation.
• Object, Scene & Label Detection - general tagging alongside moderation.
• Rekognition via SDK Best Practices - confidence-threshold tuning and review-queue design.

Stack versions: This page was written for boto3 1.43.x (Python 3.10+) and the AWS SDK for JavaScript v3 (Node.js 18+).