Authentication

All API requests require an API key. Include your API key in the request header:

X-API-Key: YOUR_API_KEY

Sign up to get your API keys and start moderating content.

Endpoints

POST /api/v1/moderate

Submit a text or image item for moderation.

Request Headers

X-API-Key	Your API key	required
Content-Type	application/json	required

Request Parameters

Parameter	Type	Description
queue	`string`	Queue slug to submit to (can be in request body or query parameter) *
item.content_type	`string`	Either "text" or "image" *
item.text_content	`string`	The text content to moderate (required if content_type is "text")
item.image	`file`	The image file to moderate (required if content_type is "image")
item.id	`string`	Custom identifier that you can use to match against your own system

Example: Submit Text

curl -X POST https://moderantai.com/api/v1/moderate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "queue": "customer-support",
    "item": {
      "content_type": "text",
      "text_content": "This is the content to moderate"
    }
  }'

fetch('https://moderantai.com/api/v1/moderate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    queue: 'customer-support',
    item: {
      content_type: 'text',
      text_content: 'This is the content to moderate'
    }
  })
})
.then(response => response.json())
.then(data => console.log(data));

import requests

url = 'https://moderantai.com/api/v1/moderate'
headers = {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
}
data = {
    'queue': 'customer-support',
    'item': {
        'content_type': 'text',
        'text_content': 'This is the content to moderate'
    }
}

response = requests.post(url, json=data, headers=headers)
print(response.json())

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://moderantai.com/api/v1/moderate')

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {
  queue: 'customer-support',
  item: {
    content_type: 'text',
    text_content: 'This is the content to moderate'
  }
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

Example: Submit Image

curl -X POST "https://moderantai.com/api/v1/moderate" \
  -H "X-API-Key: YOUR_API_KEY" \
  -F "queue=customer-support" \
  -F "item[content_type]=image" \
  -F "item[image]=@/path/to/image.jpg"

const formData = new FormData();
formData.append('queue', 'customer-support');
formData.append('item[content_type]', 'image');
formData.append('item[image]', fileInput.files[0]);

fetch('https://moderantai.com/api/v1/moderate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY'
  },
  body: formData
})
.then(response => response.json())
.then(data => console.log(data));

import requests

url = 'https://moderantai.com/api/v1/moderate'
headers = {'X-API-Key': 'YOUR_API_KEY'}
data = {'queue': 'customer-support'}
files = {
    'item[content_type]': (None, 'image'),
    'item[image]': ('image.jpg', open('/path/to/image.jpg', 'rb'), 'image/jpeg')
}

response = requests.post(url, data=data, headers=headers, files=files)
print(response.json())

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://moderantai.com/api/v1/moderate')

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'

form_data = [
  ['queue', 'customer-support'],
  ['item[content_type]', 'image'],
  ['item[image]', File.open('/path/to/image.jpg')]
]
request.set_form(form_data, 'multipart/form-data')

response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

Response: Success (201 Created)

{
  "id": 123,
  "state": "unprocessed",
  "queue": "customer-support"
}

Response: Error (401 Unauthorized)

{
  "error": "Missing API key or queue parameter"
}

{
  "error": "Invalid API key"
}

{
  "error": "Queue not found or not accessible with this API key"
}

Response: Error (422 Unprocessable Entity)

{
  "errors": [
    "Content type can't be blank",
    "Text content can't be blank"
  ]
}

Item States

Items flow through the following states:

unprocessed

Initial state when item is submitted

flagged

Item has been flagged for human review

compliant

Item approved (webhook notification sent)

non_compliant

Item rejected (webhook notification sent)

Webhooks

Configure webhooks to receive notifications when items are processed (approved or rejected).

Webhook Payload

Generic webhooks receive a standardized payload with metadata and item details:

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "event": "item.compliant",
  "timestamp": "2025-11-13T10:30:00.000Z",
  "payload": {
    "item_id": 123,
    "queue_name": "Your Queue Name",
    "state": "compliant",
    "content_type": "text",
    "text_content": "The moderated content",
    "processed_at": "2025-11-13T10:29:45.000Z",
    "violated_rules": []
  }
}

Webhook Structure

id	`string`	Unique UUID for this webhook event
event	`string`	Event type: "item.compliant", "item.non_compliant", or "item.flagged"
timestamp	`string`	ISO8601 timestamp when webhook was sent
payload	`object`	Item data and violation details

Sign up to configure webhooks for your moderation queue.

Note: Slack and Discord webhooks use platform-specific formats optimized for those services.

Rate Limits

Currently, there are no rate limits enforced. Please use the API responsibly.

API Documentation