NSFW Check API

Free NSFW Check

Free image nudity checker in your browser, plus an API that returns a verdict for every upload and every AI-generated image — with the evidence to show for it.

Free · no sign-up · JPG, PNG or WebP up to 20 MB · production API takes public HTTPS URLs

Try a free NSFW check on any image

Choose a sample, paste an image URL or select a file — one image at a time, checked in your browser with no account or credits. To check images automatically from your own product, use the API.

Local result

Select an image or a sample to start. No detection has run yet.

L1
—
L2
—
L3
—
L4
—

This trial runs a browser copy of the model. It does not create API tasks or verify API performance, billing or model-version alignment.

Local files and samples stay in your browser. Remote images may be relayed through this site without being stored. Privacy policy

How the check works

To check an image for nudity, pick a sample, paste an image URL or choose a file from your device. This NSFW image checker classifies it for nudity and sexually explicit content with a model that runs inside your browser through WebAssembly. The first check downloads about 11 MB of model and runtime files; after that, every image is analyzed on your own device.

What the check returns

Instead of a single yes-or-no answer, you get a probability for each of four levels: L1 (safe), L2 (suggestive), L3 (explicit) and L4 (most explicit), along with the most probable level. The checker also shows the verdict under both policies: the standard policy flags L3 and L4, and the strict policy flags L2 as well. See what each level means.

What the browser demo can't do

The checker is for trying the model by hand, image by image. It has no batch mode and no automation, and you can't call it from your own product. For production traffic, use the API: your server submits a public HTTPS image URL, gets a task ID at once and fetches the result asynchronously. The API takes image URLs only, not multipart file uploads. Read the full image requirements.

Is it really free?

Yes. The NSFW check on this page needs no account, API key or credits. The API is the paid part: new accounts get free starter credits, and after that each accepted task uses one credit from your plan. Querying a task is free, and a task that fails gets its credit back. Compare plans.

Built for teams that must check every image

Every upload, every generated image

The API takes an HTTPS image URL and returns one verdict: output.level from L1 to L4, the probability of each level, and output.is_nsfw under the policy you picked.

See the response fields

Submit, poll, done

POST an image URL and get a task id back at once, then query the task until it is final. Backfills, batch moderation and moderation queues fit this shape better than a blocking call.

Read the task lifecycle

You pay per accepted task

One credit per accepted task, and a task that finally fails returns its credit — queries are free. Plans start at $9/month for 30,000 checks.

See pricing

Why compliance, not just filtering

Filtering protects your users. Compliance protects your business.

Payment providers and card networks ask merchants to show how they review user content — and what they accept is a record, not a promise. "We do our best" is not an answer you can send them.

That is why this API returns probabilities instead of a black-box yes. You pick standard or strict per request, so a borderline image is judged the same way every time, and you can move the threshold without touching your integration.

Keep the task id, the timestamp and the verdict your policy produced. When someone asks what you did about a specific image, the answer is one lookup.

Policy and thresholds

What the API returns

FieldWhat it tells you
statuswaiting, processing, succeeded or failed — poll until it is final
output.levelthe most probable level, L1 (lowest risk) to L4 (most explicit)
output.probabilitiesthe probability of each level, so you set your own threshold
output.is_nsfwthe pass or flag verdict under the policy you sent

Send policy.sensitivity as standard or strict. Same model, same response shape, a stricter verdict.

  • HTTPS image URLs only
  • JPEG, PNG or WebP
  • up to 20 MiB and 8192 px
  • 40 MP
  • 50 waiting or processing tasks per account
  • Idempotency-Key so a retry never charges you twice

Full parameter listError codesRate limits

Need this on your server, for millions of images?

The browser demo checks one image at a time. The API checks them server-side, asynchronously, on the images your users upload or the model generates.

NSFW Detection API — add it to your backend in three steps

Asynchronous: submit a task, then fetch its result with the task ID.

# 1. Submit a task: the response returns at once with its ID
curl -X POST 'https://api.nsfwcheckapi.com/v1/predictions' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  --data '{"input":{"image":"https://images.example.com/photo.jpg"},
           "policy":{"sensitivity":"standard"}}'

{ "id": "TASK_ID", "status": "waiting", "output": null, ... }

# 2. Query the task by ID until it is final
curl 'https://api.nsfwcheckapi.com/v1/predictions/TASK_ID' \
  -H 'Authorization: Bearer YOUR_API_KEY'

# 3. Read output.level and output.is_nsfw from the final task
  1. 1

    Submit a task

    POST a public HTTPS image URL with your API key and choose the standard or strict policy. The response returns a task ID right away. Each accepted task uses one credit.

  2. 2

    Query the task by ID

    GET the task with its ID every 1–2 seconds until its status is succeeded or failed. Queries use no credits.

  3. 3

    Read the level and verdict

    Use output.level and the L1–L4 probabilities for your own rules, and output.is_nsfw for the decision under your policy.

Request referenceQuery referenceErrors and retries

What you get back

Query a task until it is final. A succeeded task looks like this.

output.level
The most probable of the four levels, from L1 to L4.
output.probabilities
One probability for each level, so you can apply your own thresholds.
output.is_nsfw
The verdict under the policy you sent: standard flags L3 and L4, strict also flags L2.

If a task fails, output is null, error explains why, and its credit is returned.

All response fieldsError codes

Example: a succeeded task
{
  "id": "0f8e3c52-6d1a-4b7e-9c2f-5a1b3d4e6f70",
  "model": "general",
  "status": "succeeded",
  "policy": { "sensitivity": "standard" },
  "model_version": "general-2026-08",
  "output": {
    "level": "L1",
    "probabilities": { "L1": 0.94, "L2": 0.04, "L3": 0.01, "L4": 0.01 },
    "is_nsfw": false
  },
  "error": null,
  ...
}

What is an NSFW check?

An NSFW check is an image moderation step: it classifies an image by how explicit or unsafe it is before you publish, store or show it. Instead of a single yes-or-no label, NSFW Check API returns a probability for each of four levels, ordered from L1 (lowest risk) to L4 (most explicit), together with the selected level and the model version that produced it.

PolicyL1SafeL2SuggestiveL3ExplicitL4Most explicit
Lowest riskMost explicit
Standard (default)PassPassFlaggedFlagged
StrictPassFlaggedFlaggedFlagged

Your policy turns the level into a decision. The standard policy flags L3 and L4; the strict policy also flags L2, which suits communities with stricter rules or younger audiences. Switching policy never changes the probabilities, so you can keep the raw output and revisit your choice later.

Where teams use NSFW detection

Content moderation for anywhere users or models can put an image in front of other people.

AI-generated images

Screen images from your generation pipeline before showing them to users: submit each image as a task and publish it once the result passes.

User uploads and communities

Check photos posted to forums, chats and social feeds before they appear, and send flagged images to moderators instead of reviewing every upload by hand.

Profile pictures

Screen avatars and cover images at sign-up and on every change, so explicit profile pictures never reach public profiles.

Marketplaces and listings

Check listing and product photos when a seller creates or edits a listing, and hold flagged items for review before they go live.

API plans

The NSFW check on this page is free. New API accounts get free starter credits; after that, each image checked through the API uses one credit from your plan.

Starter

$9/month

  • 30,000 credits / month
  • ≈ $0.30 per 1,000 images

Growth

$19/month

  • 100,000 credits / month
  • ≈ $0.19 per 1,000 images

Pro

$39/month

  • 300,000 credits / month
  • ≈ $0.13 per 1,000 images

Frequently asked questions

About the free NSFW check and the NSFW Check API.

Is this NSFW check really free?

Yes. The NSFW check on this page is free and needs no account or credits. It runs in your browser, so local files are never uploaded. For batches and automation, use the API, which starts with free credits when you sign up. See pricing.

Do my images get uploaded to your server?

Not when you check local files or samples on this page: they are analyzed in your browser and never leave your device. If you paste an image URL and its host blocks cross-site requests, the image is relayed through this site without being stored. With the API, your server sends an image URL instead. How the API takes images.

Can I check a batch of images?

Not on this page: the browser checker takes a single image per check. With the API, your server submits one task per image, with up to 50 tasks waiting or processing at once per account, and collects each result by its task ID. See the API.

Which images can the NSFW check process?

Public HTTPS static JPEG, PNG and WebP images, up to 20 MiB, 8192 pixels on each side and 40 million pixels total. GIF, APNG and animated WebP are not supported.

How accurate is the NSFW check?

The model returns probabilities, not certainties, and no accuracy guarantee is made. Use the strict policy when missing explicit content costs more than over-flagging, and route borderline results to human review.

How fast is an NSFW check?

Tasks run asynchronously: submitting returns a task ID at once, and you query that ID until the task is final. A task that cannot finish within 20 minutes fails and its credit is returned. No completion-time guarantee is made.

Are images stored after an NSFW check?

The platform does not host or snapshot your images; the inference service downloads the URL when the task runs. Task records, results and encrypted image URLs stay in your account history. Customer images are not used to train models.

Is NSFW Check API the same as nsfwcheckapi.com?

Yes. NSFW Check API is the service at nsfwcheckapi.com: the free NSFW check on this page, plus the detection API, documentation and dashboard behind it.

What is an "NSFW check API"?

An NSFW check API lets your backend ask whether an image is explicit before you publish, store or show it, without a person reviewing every upload. Ours takes a public HTTPS image URL, checks it asynchronously and returns L1–L4 probabilities plus a pass or flag verdict under your policy.

Can I use it as an NSFW filter for uploads?

Yes. Submit each image as a task when it is uploaded or generated, and hold it until the result is final. Publish images that pass your policy, and block flagged ones or send them to human review. Use the strict policy for communities with stricter rules or younger audiences.

Add NSFW detection to your app today.

Sign up to receive free starter credits, create an API key, and follow the integration guide to send your first image.