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.
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 fieldsSubmit, 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 lifecycleYou 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 pricingWhy 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.
What the API returns
| Field | What it tells you |
|---|---|
status | waiting, processing, succeeded or failed — poll until it is final |
output.level | the most probable level, L1 (lowest risk) to L4 (most explicit) |
output.probabilities | the probability of each level, so you set your own threshold |
output.is_nsfw | the 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
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
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
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
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.
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.
{
"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.
| Policy | L1Safe | L2Suggestive | L3Explicit | L4Most explicit |
|---|---|---|---|---|
Lowest riskMost explicit | ||||
| Standard (default) | Pass | Pass | Flagged | Flagged |
| Strict | Pass | Flagged | Flagged | Flagged |
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.