Protect Your Community with AI-Powered Content Moderation

apiKey = $apiKey;
    }

    public function moderateContent($content, $projectId) {
        $data = [
            'content' => $content,
            'projectId' => $projectId
        ];

        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->baseUrl . '/moderate');
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json'
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }
}

// Usage
$moderator = new ContentShieldAI('YOUR_API_KEY');
$result = $moderator->moderateContent('User comment here', 'project-id');

if ($result['passed']) {
    // Safe to publish
    echo "Content approved";
} else {
    echo "Content blocked: " . $result['description'];
}
?>

// Go Example
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type ModerationRequest struct {
    Content   string `json:"content"`
    ProjectID string `json:"projectId"`
}

type ModerationResponse struct {
    Context     string  `json:"context"`
    Score       int     `json:"score"`
    Passed      bool    `json:"passed"`
    Description string  `json:"description"`
}

func moderateContent(content, projectID, apiKey string) (*ModerationResponse, error) {
    req := ModerationRequest{
        Content:   content,
        ProjectID: projectID,
    }

    jsonData, err := json.Marshal(req)
    if err != nil {
        return nil, err
    }

    httpReq, err := http.NewRequest("POST",
        "https://api.contentshieldai.com/moderate",
        bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    httpReq.Header.Set("Authorization", "Bearer "+apiKey)
    httpReq.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(httpReq)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result ModerationResponse
    err = json.Unmarshal(body, &result)
    return &result, err
}

func main() {
    result, err := moderateContent(
        "This is a test comment",
        "your-project-id",
        "YOUR_API_KEY")

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    if result.Passed {
        fmt.Println("Content approved for publication")
    } else {
        fmt.Printf("Content blocked: %s\n", result.Description)
    }
}

// .NET C# Example
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class ContentShieldAI
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private const string BaseUrl = "https://api.contentshieldai.com";

    public ContentShieldAI(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
    }

    public async Task ModerateContentAsync(string content, string projectId)
    {
        var request = new
        {
            content = content,
            projectId = projectId
        };

        var json = JsonSerializer.Serialize(request);
        var httpContent = new StringContent(json, Encoding.UTF8, "application/json");

        try
        {
            var response = await _httpClient.PostAsync($"{BaseUrl}/moderate", httpContent);
            var responseString = await response.Content.ReadAsStringAsync();

            return JsonSerializer.Deserialize(responseString,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }
        catch (Exception ex)
        {
            throw new Exception($"Moderation failed: {ex.Message}");
        }
    }
}

public class ModerationResult
{
    public string Context { get; set; }
    public int Score { get; set; }
    public bool Passed { get; set; }
    public string Description { get; set; }
}

// Usage example
class Program
{
    static async Task Main(string[] args)
    {
        var moderator = new ContentShieldAI("YOUR_API_KEY");

        var result = await moderator.ModerateContentAsync(
            "This is a user comment",
            "your-project-id");

        if (result.Passed)
        {
            Console.WriteLine("Content approved for publication");
        }
        else
        {
            Console.WriteLine($"Content blocked: {result.Description}");
        }
    }
}