ModerateAPI Documentation

curl -X POST https://moderateapi.com/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "your@email.com",
    "password": "your_secure_password"
  }'

Response:

{
  "success": true,
  "message": "User created successfully",
  "user_id": 123,
  "api_key": {
    "key": "mk_abc123...",
    "name": "Default Key",
    "prefix": "mk_abc12"
  },
  "plan": "free",
  "monthly_limit": 1000
}

curl -X POST https://moderateapi.com/api/v1/moderate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "text": "This is a test message",
    "context": "comment"
  }'

Response:

{
  "safe": true,
  "confidence": 0.95,
  "issues": [],
  "suggested_action": "approve",
  "from_cache": false,
  "request_id": "unique_id",
  "response_time_ms": 85,
  "text_length": 21
}

POST /api/v1/moderate HTTP/1.1
Host: moderateapi.com
Content-Type: application/json
X-API-Key: mk_your_api_key_here

{
  "text": "Content to moderate"
}

POST /api/v1/moderate HTTP/1.1
Host: moderateapi.com
Content-Type: application/json
Authorization: Bearer mk_your_api_key_here

{
  "text": "Content to moderate"
}

HTTP/1.1 200 OK
X-RateLimit-Limit: 50
X-RateLimit-Remaining: 47
X-RateLimit-Reset: 1640995200

{
  "error": "API key required",
  "request_id": "req_abc123",
  "timestamp": "2024-01-15T10:30:00Z"
}

try {
  const response = await fetch('https://moderateapi.com/api/v1/moderate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': 'your-api-key'
    },
    body: JSON.stringify({ text: 'Content to moderate' })
  });

  if (!response.ok) {
    if (response.status === 429) {
      console.log('Rate limit exceeded, please wait');
      return;
    }
    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
  }

  const result = await response.json();
  console.log('Moderation result:', result);
} catch (error) {
  console.error('Moderation failed:', error.message);
}

curl -X POST https://moderateapi.com/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "developer@example.com",
    "password": "secure_password123"
  }'

{
  "success": true,
  "message": "User created successfully",
  "user_id": 123,
  "api_key": {
    "key": "mk_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h",
    "name": "Default Key",
    "prefix": "mk_1a2b3c"
  },
  "plan": "free",
  "monthly_limit": 1000,
  "usage": {
    "current_month": 0,
    "remaining": 1000
  }
}

Content-Type: application/json
X-API-Key: mk_your_api_key_here

curl -X POST https://moderateapi.com/api/v1/moderate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: mk_your_api_key_here" \
  -d '{
    "text": "Hey everyone! Check out this amazing product, click here to win $1000 now!",
    "context": "comment"
  }'

{
  "safe": false,
  "confidence": 0.87,
  "issues": [
    {
      "type": "spam",
      "severity": "medium",
      "confidence": 0.85
    },
    {
      "type": "urgency_scam",
      "severity": "high",
      "confidence": 0.78
    }
  ],
  "suggested_action": "block",
  "from_cache": false,
  "request_id": "req_abc123def456",
  "response_time_ms": 152,
  "text_length": 79
}

X-API-Key: mk_your_api_key_here

curl -X GET https://moderateapi.com/api/v1/usage \
  -H "X-API-Key: mk_your_api_key_here"

{
  "user_id": 123,
  "plan": {
    "name": "growth",
    "display_name": "Growth Plan",
    "monthly_limit": 100000,
    "rate_limit": 200
  },
  "current_month": {
    "calls_used": 15420,
    "calls_limit": 100000,
    "remaining_calls": 84580,
    "usage_percentage": 15.42,
    "period_start": "2024-01-01T00:00:00Z",
    "period_end": "2024-01-31T23:59:59Z"
  },
  "api_keys": [
    {
      "name": "Production Key",
      "prefix": "mk_1a2b3c",
      "created": "2024-01-01T10:30:00Z",
      "last_used": "2024-01-15T14:22:33Z",
      "status": "active",
      "calls_this_month": 15420
    }
  ],
  "billing": {
    "subscription_status": "active",
    "next_billing_date": "2024-02-01T00:00:00Z",
    "amount": 99.00,
    "currency": "USD"
  }
}

const API_KEY = 'mk_your_api_key_here';
const BASE_URL = 'https://moderateapi.com/api/v1';

async function moderateContent(text, context = null) {
  try {
    const response = await fetch(`${BASE_URL}/moderate`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': API_KEY
      },
      body: JSON.stringify({
        text: text,
        ...(context && { context })
      })
    });

    if (!response.ok) {
      if (response.status === 429) {
        throw new Error('Rate limit exceeded. Please wait before making more requests.');
      }
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    return result;
  } catch (error) {
    console.error('Moderation failed:', error.message);
    throw error;
  }
}

// Usage example
async function main() {
  try {
    const result = await moderateContent(
      "This is some content to moderate",
      "comment"
    );

    console.log('Safe:', result.safe);
    console.log('Confidence:', result.confidence);
    console.log('Action:', result.suggested_action);

    if (result.issues.length > 0) {
      console.log('Issues found:');
      result.issues.forEach(issue => {
        console.log(`- ${issue.type} (${issue.severity}): ${issue.confidence}`);
      });
    }
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

class ModerateAPIClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://moderateapi.com/api/v1';
    this.rateLimitRetries = 3;
  }

  async moderate(text, context = null, retryCount = 0) {
    try {
      const response = await fetch(`${this.baseUrl}/moderate`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-API-Key': this.apiKey
        },
        body: JSON.stringify({
          text: text,
          ...(context && { context })
        })
      });

      if (response.status === 429 && retryCount < this.rateLimitRetries) {
        // Exponential backoff for rate limiting
        const delay = Math.pow(2, retryCount) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        return this.moderate(text, context, retryCount + 1);
      }

      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(errorData.error || `HTTP ${response.status}`);
      }

      return await response.json();
    } catch (error) {
      if (error.name === 'TypeError' && error.message.includes('fetch')) {
        throw new Error('Network error. Please check your connection.');
      }
      throw error;
    }
  }

  async getUsage() {
    const response = await fetch(`${this.baseUrl}/usage`, {
      headers: { 'X-API-Key': this.apiKey }
    });

    if (!response.ok) {
      throw new Error(`Failed to get usage: ${response.status}`);
    }

    return await response.json();
  }
}

// Usage
const client = new ModerateAPIClient('mk_your_api_key_here');

client.moderate('Content to check')
  .then(result => {
    if (result.safe) {
      console.log('✅ Content is safe');
    } else {
      console.log('⚠️ Content flagged:', result.issues);
    }
  })
  .catch(error => console.error('Error:', error.message));

import requests
import time
from typing import Optional, Dict, Any

class ModerateAPIClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://moderateapi.com/api/v1'
        self.session = requests.Session()
        self.session.headers.update({
            'X-API-Key': api_key,
            'Content-Type': 'application/json'
        })

    def moderate(self, text: str, context: Optional[str] = None,
                 max_retries: int = 3) -> Dict[str, Any]:
        """
        Moderate text content using the ModerateAPI service.

        Args:
            text: Content to moderate
            context: Optional context hint
            max_retries: Maximum retry attempts for rate limiting

        Returns:
            Dictionary containing moderation results

        Raises:
            requests.RequestException: For API errors
        """
        payload = {'text': text}
        if context:
            payload['context'] = context

        for attempt in range(max_retries + 1):
            try:
                response = self.session.post(
                    f'{self.base_url}/moderate',
                    json=payload,
                    timeout=30
                )

                if response.status_code == 429:  # Rate limited
                    if attempt < max_retries:
                        delay = 2 ** attempt  # Exponential backoff
                        print(f"Rate limited. Waiting {delay}s before retry...")
                        time.sleep(delay)
                        continue
                    else:
                        raise requests.RequestException("Rate limit exceeded")

                response.raise_for_status()
                return response.json()

            except requests.RequestException as e:
                if attempt == max_retries:
                    raise
                print(f"Request failed (attempt {attempt + 1}): {e}")
                time.sleep(1)

    def get_usage(self) -> Dict[str, Any]:
        """Get account usage statistics."""
        response = self.session.get(f'{self.base_url}/usage')
        response.raise_for_status()
        return response.json()

    def register_user(self, email: str, password: str) -> Dict[str, Any]:
        """Register a new user account."""
        response = requests.post(
            f'{self.base_url}/register',
            json={'email': email, 'password': password}
        )
        response.raise_for_status()
        return response.json()

# Usage example
def main():
    client = ModerateAPIClient('mk_your_api_key_here')

    try:
        # Moderate some content
        result = client.moderate(
            "This is some text to check for safety",
            context="comment"
        )

        print(f"Safe: {result['safe']}")
        print(f"Confidence: {result['confidence']:.2f}")
        print(f"Suggested action: {result['suggested_action']}")

        if result['issues']:
            print("\nIssues detected:")
            for issue in result['issues']:
                print(f"  - {issue['type']} ({issue['severity']}): "
                      f"{issue['confidence']:.2f}")

        # Check usage
        usage = client.get_usage()
        print(f"\nAPI Usage: {usage['current_month']['calls_used']} / "
              f"{usage['current_month']['calls_limit']}")

    except requests.RequestException as e:
        print(f"API Error: {e}")

if __name__ == "__main__":
    main()

import aiohttp
import asyncio
from typing import Optional, Dict, Any, List

class AsyncModerateAPIClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://moderateapi.com/api/v1'
        self.headers = {
            'X-API-Key': api_key,
            'Content-Type': 'application/json'
        }

    async def moderate(self, text: str, context: Optional[str] = None) -> Dict[str, Any]:
        """Moderate text content asynchronously."""
        payload = {'text': text}
        if context:
            payload['context'] = context

        async with aiohttp.ClientSession() as session:
            async with session.post(
                f'{self.base_url}/moderate',
                json=payload,
                headers=self.headers
            ) as response:
                if response.status == 429:
                    raise aiohttp.ClientResponseError(
                        None, None, status=429,
                        message="Rate limit exceeded"
                    )
                response.raise_for_status()
                return await response.json()

    async def moderate_batch(self, texts: List[str],
                           context: Optional[str] = None) -> List[Dict[str, Any]]:
        """Moderate multiple texts concurrently."""
        tasks = [self.moderate(text, context) for text in texts]
        return await asyncio.gather(*tasks, return_exceptions=True)

# Usage example
async def main():
    client = AsyncModerateAPIClient('mk_your_api_key_here')

    # Single moderation
    result = await client.moderate("Text to moderate")
    print(f"Result: {result['safe']}")

    # Batch moderation
    texts = [
        "First comment to check",
        "Second comment to check",
        "Third comment to check"
    ]

    results = await client.moderate_batch(texts, context="comment")

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Text {i+1} failed: {result}")
        else:
            print(f"Text {i+1}: {'Safe' if result['safe'] else 'Flagged'}")

# Run the async example
# asyncio.run(main())

<?php

class ModerateAPIClient {
    private $apiKey;
    private $baseUrl;

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
        $this->baseUrl = 'https://moderateapi.com/api/v1';
    }

    public function moderate($text, $context = null) {
        $data = ['text' => $text];
        if ($context) {
            $data['context'] = $context;
        }

        $response = $this->makeRequest('POST', '/moderate', $data);
        return $response;
    }

    public function getUsage() {
        return $this->makeRequest('GET', '/usage');
    }

    public function registerUser($email, $password) {
        $data = [
            'email' => $email,
            'password' => $password
        ];
        return $this->makeRequest('POST', '/register', $data, false);
    }

    private function makeRequest($method, $endpoint, $data = null, $useAuth = true) {
        $url = $this->baseUrl . $endpoint;

        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 30,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HTTPHEADER => $this->getHeaders($useAuth),
            CURLOPT_SSL_VERIFYPEER => true,
        ]);

        if ($data && in_array($method, ['POST', 'PUT', 'PATCH'])) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        curl_close($ch);

        if ($error) {
            throw new Exception("cURL Error: " . $error);
        }

        $decodedResponse = json_decode($response, true);

        if ($httpCode >= 400) {
            $errorMessage = isset($decodedResponse['error'])
                ? $decodedResponse['error']
                : "HTTP $httpCode";
            throw new Exception($errorMessage);
        }

        return $decodedResponse;
    }

    private function getHeaders($useAuth = true) {
        $headers = ['Content-Type: application/json'];

        if ($useAuth) {
            $headers[] = 'X-API-Key: ' . $this->apiKey;
        }

        return $headers;
    }
}

// Usage example
try {
    $client = new ModerateAPIClient('mk_your_api_key_here');

    // Moderate content
    $result = $client->moderate(
        "This is some content to check",
        "comment"
    );

    echo "Safe: " . ($result['safe'] ? 'Yes' : 'No') . "\n";
    echo "Confidence: " . round($result['confidence'], 2) . "\n";
    echo "Action: " . $result['suggested_action'] . "\n";

    if (!empty($result['issues'])) {
        echo "\nIssues detected:\n";
        foreach ($result['issues'] as $issue) {
            echo "- {$issue['type']} ({$issue['severity']}): " .
                 round($issue['confidence'], 2) . "\n";
        }
    }

    // Check usage
    $usage = $client->getUsage();
    echo "\nAPI Usage: {$usage['current_month']['calls_used']} / " .
         "{$usage['current_month']['calls_limit']}\n";

} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

?>

# Basic content moderation
curl -X POST https://moderateapi.com/api/v1/moderate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: mk_your_api_key_here" \
  -d '{
    "text": "This is content to moderate",
    "context": "comment"
  }'

# Register new user
curl -X POST https://moderateapi.com/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "secure_password123"
  }'

# Get account usage
curl -X GET https://moderateapi.com/api/v1/usage \
  -H "X-API-Key: mk_your_api_key_here"

#!/bin/bash

API_KEY="mk_your_api_key_here"
BASE_URL="https://moderateapi.com/api/v1"

# Function to moderate content with error handling
moderate_content() {
    local text="$1"
    local context="${2:-}"

    local payload="{\"text\": \"$text\""
    if [ -n "$context" ]; then
        payload="$payload, \"context\": \"$context\""
    fi
    payload="$payload}"

    response=$(curl -s -w "%{http_code}" -X POST "$BASE_URL/moderate" \
        -H "Content-Type: application/json" \
        -H "X-API-Key: $API_KEY" \
        -d "$payload")

    http_code="${response: -3}"
    body="${response%???}"

    case $http_code in
        200)
            echo "Success: $body"
            ;;
        400)
            echo "Bad Request: $body"
            exit 1
            ;;
        401)
            echo "Unauthorized: Check your API key"
            exit 1
            ;;
        429)
            echo "Rate limited: Please wait before trying again"
            exit 1
            ;;
        *)
            echo "Error $http_code: $body"
            exit 1
            ;;
    esac
}

# Usage
moderate_content "Content to check" "comment"

Suggested Actions Guide