Name: NSFW Video Detection – Moderate Content | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-nsfw-video-content-detection
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🚫 NSFW Video Content Detection API (FalconAIs, lucataco)

## Overview
Easily detect and flag Not-Safe-For-Work (NSFW) content in video files with this AI-driven API. Designed for scalable content moderation, it processes video input to identify adult or unsafe material, making it an essential tool for platforms handling user-generated or large-scale video content.

![Sample video input for NSFW detection](https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4)

## Features
- Rapid video scanning for NSFW content using advanced AI models  
- Adjustable safety tolerance to fine-tune strictness levels  
- Highly scalable asynchronous processing for large or frequent video uploads  
- Results delivered with clear status indicators, allowing straightforward integration into moderation workflows  
- Comprehensive status lifecycle (starting → processing → succeeded/failed) for robust handling of asynchronous tasks  

## Use Cases
1. Moderation for Social Media: Automatically screen uploaded user videos for explicit or sexual content before publishing.  
2. Video Hosting Platforms: Large-scale scanning of incoming video streams to ensure compliance with community standards.  
3. Adult Content Filters: Maintain safe user environments by filtering out NSFW material in corporate or educational settings.  
4. Advertising Platforms: Prevent brand-unsafe content from appearing in video ads.  
5. Automated Monitoring: Continuous auditing of archived video libraries to identify non-compliant clips.

## Examples
Below is an example of a video input used with this API. The API returns a result indicating whether the content is “normal” or flagged for NSFW.

![Video used for NSFW detection](https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4)

A typical prediction request with this video might look like this in JSON:
```json
{
  "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
  "input": {
    "video": "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
    "safety_tolerance": 2
  }
}
```

An example of a successful output in JSON might be:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "normal",
  "created_at": "2025-04-21T10:44:12.948Z",
  "started_at": "2025-04-21T10:44:18.123Z",
  "completed_at": "2025-04-21T10:44:35.432Z"
}
```

## Pricing
• 1 API unit corresponds to processing 1 video.  
• GET requests to retrieve prediction status (GET /api/v1/magicapi/nsfw-video-content-detection/predictions/{id}) are free and do not count toward API unit usage.  
• Various pricing tiers are available based on your monthly video processing volume.

## API Documentation

### Base URL
All requests should be sent to:  
```
https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection
```

### Authentication
Include your API key with every request:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API performs NSFW video detection asynchronously. The typical flow:

1. Send a POST request with your video URL.  
2. Receive a prediction ID immediately.  
3. Poll the GET endpoint with the prediction ID to check status.  
4. Continue polling until the status is “succeeded” or “failed.”  

Implementation details:  
- Poll at 1-second intervals.  
- Maximum wait time is 10 minutes (600 seconds).  
- If the status is “succeeded,” process results.  
- If “failed” or if time exceeds 600 seconds, handle the error gracefully.

### Endpoints

#### 1. Create a Prediction  
• Method: POST  
• Endpoint: /api/v1/magicapi/nsfw-video-content-detection/predictions  

Request Body (JSON):
```json
{
  "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
  "input": {
    "video": "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
    "safety_tolerance": 2
  }
}
```

Response (201 Created on success):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
  "status": "starting",
  "created_at": "2025-04-21T10:44:12.948Z"
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
    "input": {
      "video": "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
      "safety_tolerance": 2
    }
  }'
```

#### 2. Get Prediction Status and Results  
• Method: GET  
• Endpoint: /api/v1/magicapi/nsfw-video-content-detection/predictions/{id}

Response (200 OK on success):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "normal",
  "created_at": "2025-04-21T10:44:12.948Z",
  "started_at": "2025-04-21T10:44:18.123Z",
  "completed_at": "2025-04-21T10:44:35.432Z"
}
```

Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

## Status Codes
Below are the main HTTP status codes you may encounter:

- 200 OK: Request was successful.  
- 201 Created: Resource successfully created (e.g., you created a new prediction).  
- 400 Bad Request: Invalid input parameters or malformed request.  
- 401 Unauthorized: The API key is missing or invalid.  
- 403 Forbidden: The API key is valid but not authorized to access this resource.  
- 404 Not Found: The specified prediction or resource does not exist.  
- 429 Too Many Requests: You have hit a rate limit; wait or upgrade your plan.  
- 500 Internal Server Error: There was an error on the server side.  
- 503 Service Unavailable: The service is temporarily not available.  

## Rate Limits
Depending on your usage tier, you may encounter rate limits. To handle them:
- Implement exponential backoff when you receive 429 status codes.  
- Consider upgrading to a higher tier if you frequently encounter rate limits.

## Error Handling
When the API returns an error, it will typically include a JSON payload with details:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'video' is required",
    "status": 400
  }
}
```
To handle errors:
- Check the “code” and “message” fields to identify the issue.  
- If it’s a client-side error (4xx), correct your request.  
- If it’s a server-side error (5xx), implement a retry strategy with a short delay.  
- If it’s a 429 rate limit error, wait or reduce your request frequency.

## Implementation Guide

### Example Code

Below are examples in JavaScript, Python, and cURL demonstrating how to:
1. Authenticate using your API key  
2. Make the prediction request (POST)  
3. Poll for completion (GET)  
4. Handle errors and timeouts  

#### JavaScript (Node.js)
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
        input: inputData
      })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();
    const predictionId = prediction.id;

    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 10 minutes
  const POLL_INTERVAL = 1000; // 1 second

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-magicapi-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    } else if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

// Usage Example:
(async () => {
  const input = {
    video: "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
    safety_tolerance: 2
  };

  try {
    const result = await createAndWaitForPrediction(input);
    console.log("Prediction output:", result);
  } catch (error) {
    console.error("Prediction error:", error);
  }
})();
```

#### Python
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
            "input": input_data
        }
    )

    if response.status_code not in [200, 201]:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 10 minutes
    POLL_INTERVAL = 1  # 1 second

    headers = {"x-magicapi-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]
        elif prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")

# Usage:
if __name__ == "__main__":
    input_data = {
        "video": "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
        "safety_tolerance": 2
    }

    try:
        result = create_and_wait_for_prediction(input_data)
        print("Prediction output:", result)
    except Exception as e:
        print("Error:", e)
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ef94e6bbf329eebc092601a647996431056a58f479d0f4129ea6e8171374d158",
    "input": {
      "video": "https://replicate.delivery/pbxt/MeYrKketDRwUdUPYlHEsA0UlcD4eOlFegxJwvJzFuhL1en1O/falcon2.mp4",
      "safety_tolerance": 2
    }
  }'

# Sample response:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   "status": "starting",
#   ...
# }

# Step 2: Check prediction status (replace with the actual prediction ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/nsfw-video-content-detection/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Batch your requests where possible.  
- Use efficient polling (1-second intervals generally suffice).  
- If you frequently need results faster or are processing large volumes, consider upgrading your plan or distributing requests across multiple workflows.

## FAQ
1. **How do I handle very large video files?**  
   Upload them to a secure location and provide the direct link as “video.” Ensure your server can stream them reliably.

2. **Which video formats are supported?**  
   Most common video formats (e.g., MP4) are supported as long as they can be hosted and accessed via HTTPS.

3. **Can I adjust the sensitivity?**  
   Yes, use the “safety_tolerance” parameter (1 is strictest, 6 is most permissive).

4. **Do GET requests cost API units to check the status?**  
   No, GET status checks are free.  

5. **What if the video is partially NSFW?**  
   The model processes the entire video. If any segment is flagged as NSFW, the final output indicates NSFW content.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello[at]api.market.

Automatically scan and detect NSFW content in videos. Adjustable safety tolerance. Free 5 calls/mo, from $5/mo. Start free on API.market.

NSFW Video Detection – Moderate Content | Free · $5/mo | API.market

🚫 NSFW Video Content Detection API (FalconAIs, lucataco)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Automatically scan videos for NSFW content with high accuracy—ideal for content moderation and fast, large-scale processing.