How to Detect NSFW Images with AI: The Developer's Guide to Image Moderation APIs

If your app accepts image uploads from users, you have an NSFW problem. It’s not a question of if someone will upload inappropriate content — it’s when. And when it happens, you need a way to check the image before other users see it.

Manual review alone becomes difficult as upload volume grows. AI-powered NSFW detection can screen every image and route the uncertain cases to people. This guide covers how image moderation works, what to look for in an API, and how to build that decision into an upload pipeline.

What Counts as NSFW Content?

NSFW (Not Safe For Work) is a broad category. Your policy may need to cover several kinds of content:

Nudity and sexual content: Full or partial nudity, sexually explicit material, suggestive poses
Violence and gore: Graphic injuries, blood, physical harm, weapon brandishing
Disturbing content: Self-harm depictions, animal cruelty, shocking imagery
Drug-related content: Drug use depictions, paraphernalia
Hate symbols: Extremist imagery and offensive symbols

Don’t assume every API detects every item on that list. Check its documented categories and test the ones your product needs. A medical education platform might allow anatomical images but block sexual content. A news platform might allow some violent imagery in a journalistic context but block graphic gore.

How AI NSFW Detection Works

Image moderation models analyze visual features and return signals that an application can use to make a policy decision. A typical pipeline looks like this:

Image ingestion: Receive an image URL or upload.
Preprocessing: Prepare the image for the model.
Visual analysis: Examine subjects, objects, and scene context.
Classification: Identify supported content categories.
Result: Return the provider’s documented labels, flags, likelihoods, or scores.

That last step varies more than it sounds. AWS Rekognition provides moderation labels; Google SafeSearch reports likelihood levels for five categories. Neither response should be treated as a universal definition of “safe.” Your application still needs to decide what each signal means for its audience.

Context matters, too. A Renaissance painting and an explicit photograph may both contain nudity, yet call for different treatment under your policy. Test those distinctions instead of assuming a model will make the same decision your reviewers would.

What to Look For in an NSFW Detection API

Not all NSFW detection APIs are created equal. Here’s what matters:

Accuracy

False positives: Legitimate content, such as swimwear photos, medical images, or art, should not be blocked unnecessarily.
False negatives: Content that violates your policy should not pass unnoticed.
Edge cases: Include cartoons, AI-generated images, partially obscured content, and the image types your users actually upload.

Speed

End-to-end time: Measure from upload submission to a usable moderation result, including queueing and polling.
Tail latency: Check slow requests as well as typical ones. Your upload flow needs a rule for results that arrive late.

Cost

Per-image pricing: Estimate spend at your upload volume.
Additional work: Include retries, other moderation models, and human review in the budget.

Integration

Simple REST API: Confirm the authentication, submission, and result-retrieval steps.
Supported inputs: Check whether the endpoint accepts a public image URL, an uploaded file, or both.
Usable output: Verify the exact response your application will receive before writing policy rules around it.

Context Support

Text context: Associated captions or descriptions may help with ambiguous images; test whether they improve decisions on your content.
Configurable decisions: You can set thresholds in your own application if the response contains suitable scores. Don’t assume every endpoint exposes a threshold parameter or a numeric score.

NSFW Detection with WaveSpeedAI

WaveSpeedAI’s Image Content Moderator accepts an image and optional associated text. Its model page lists $0.002 per image as of October 28, 2026. Check the displayed price again before setting a production budget.

Dead Simple Integration

Send an image value to wavespeed-ai/content-moderator/image; add text when the associated context is relevant. The model page accepts an uploaded image or a public URL. For an API request using a URL, make sure the service can access it.

The WaveSpeedAI API reference documents an asynchronous flow: submit once, receive a prediction ID, then query its result. This example uses curl and jq:

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

submit=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/wavespeed-ai/content-moderator/image" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image":"https://your-domain.example/uploads/pending/123.jpg",
       "text":"Product listing: kitchen knife"}')

printf '%s\n' "$submit" | jq .
result_url=$(printf '%s' "$submit" | jq -r '.data.urls.get')

while :; do
  result=$(curl --silent --show-error --fail-with-body \
    -H "Authorization: Bearer $WAVESPEED_API_KEY" "$result_url")
  status=$(printf '%s' "$result" | jq -r '.data.status')

  case "$status" in
    completed) printf '%s\n' "$result" | jq .; break ;;
    failed|cancelled|timeout|deleted)
      printf '%s\n' "$result" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done

A successful submission has a documented response envelope like this. The ID and URL below are illustrative:

{
  "code": 200,
  "message": "success",
  "data": {
    "id": "pred_abc123",
    "model": "wavespeed-ai/content-moderator/image",
    "status": "created",
    "urls": {
      "get": "https://api.wavespeed.ai/api/v3/predictions/pred_abc123/result"
    }
  }
}

When the task is completed, inspect data.outputs in the full result printed by the script. The public API reference documents that field but does not provide a fixed, image-moderation-specific example of its category names or score structure. Capture a result from an authorized test image before coding a parser; don’t invent a nsfw_score field. In production, handle temporary polling errors with backoff. If submission times out, check whether the task was created before submitting again, or you may create a second billable task.

Ultra-Affordable Pricing

At the currently listed $0.002 per image, the base API estimate is straightforward:

Volume	Base moderation cost
1,000 images/day	$2/day; $60 per 30-day month
10,000 images/day	$20/day; $600 per 30-day month
100,000 images/day	$200/day; $6,000 per 30-day month
1,000,000 images/day	$2,000/day; $60,000 per 30-day month

These are calculations from the listed unit price, not measured bills. They exclude retries, other API calls, storage, and human review. Compare total workflow cost with alternatives rather than claiming a fixed saving over a moderation team.

No Cold Starts

WaveSpeedAI describes this endpoint as having no cold starts. That is a platform claim, not a guarantee that every result arrives immediately: upload time, queueing, and task completion can still affect the user’s wait. Measure end-to-end latency on your own traffic before promising instant moderation.

Context-Aware Moderation

The optional text parameter lets you send a caption, post text, or product description with an image. A knife in a cooking listing and the same image paired with a threat may need different treatment. Include text when your policy depends on it, then compare decisions on a labeled test set to see whether it helps.

Building a Production NSFW Filter: Step by Step

Step 1: Intercept Uploads

Add moderation between upload and publication. Keep the image in a pending state until your application has made a decision, and prevent pending files from appearing in public feeds or search results.

Step 2: Call the Moderation API

Submit each uploaded image to the WaveSpeedAI Image Content Moderator. Include associated text when available and relevant. Store the prediction ID so a delayed result can still be matched to the right upload.

Step 3: Implement a Decision Framework

Use the actual returned fields and your written policy to route content:

Auto-approve: Publish when the result passes your tested policy rules.
Queue for review: Hold ambiguous content, unsupported categories, unexpected output, or cases near a validated threshold.
Auto-block: Reject clear violations under rules you have tested and documented.

If a provider supplies numeric scores, treat them as model-specific signals, not interchangeable probabilities across APIs. For example, OpenAI’s moderation guide describes category scores and warns that score-based policies may need recalibration when its model changes. Set any approve, review, and block boundaries using your own labeled images. If the WaveSpeedAI result you receive has no suitable score, route by its documented labels or flags instead of inventing a numeric cutoff.

Step 4: Handle Edge Cases

Animated GIFs: Check whether the API covers the frames you care about; otherwise extract and moderate selected frames.
Image-in-image: Include examples where a small unsafe image appears inside a larger one.
AI-generated content: Test synthetic images alongside photographs.
Failures and delays: Keep the upload pending when a task fails or times out. Don’t silently publish it.

Step 5: Add Video Moderation

If your platform handles video, evaluate WaveSpeedAI’s Video Content Moderator separately. Validate its coverage on clips representative of your uploads before assuming one video result catches every brief event in the timeline.

How to Set Thresholds and Measure Errors

Start with a small, authorized set of images that reflects your policy: ordinary uploads, allowed but sensitive material such as medical or art images, and appropriate boundary examples. Have reviewers label each sample without seeing the model’s answer. Then record false positives, false negatives, the category involved, and the decision each proposed rule would make.

Review the mistakes by category. A threshold that works for explicit nudity may be wrong for medical imagery or violence in news photos. Set a human-review band around uncertain decisions, check appeal outcomes, and repeat the evaluation when the model or your policy changes. Any threshold in a tutorial is only an example until it has been tested on your own content.

Beyond Binary: Advanced Image Analysis

Sometimes you need more than a safe/unsafe flag. WaveSpeedAI’s broader content detection model suite includes image captioning, image question answering, and text moderation. These can provide additional context for a reviewer or a separate policy check.

Keep those outputs separate from the primary moderation decision. A caption or answer can be wrong, and an extra model call adds cost. Test whether the additional signal changes decisions before putting it in every upload path.

Common Pitfalls to Avoid

Moderating only a sample: If your policy requires screening before publication, check every image that can become public.
Blocking without feedback: Tell users what policy area led to a rejection, without exposing detailed rules that make evasion easier. Provide an appeal path.
Ignoring cultural context: A dating app and a children’s game need different policies, even when they use the same API.
Skipping re-moderation: Reassess existing content when a meaningful policy or model change affects earlier decisions.
No human escalation path: AI handles volume; people handle disputes and difficult context. Keep a review queue for ambiguous cases and appeals.

Start Filtering NSFW Content Today

A useful first release is small: hold uploads, call the moderator, inspect a real response, and route each result through a documented policy. Test the boundary cases before automating blocks. The current $0.002-per-image listing gives you a base cost estimate; your own results will tell you what the full workflow costs and where reviewers are still needed.

Try the Image Content Moderator →

Explore all Content Detection Models →

Previous posts: