Unity Chat Filter Integration: Developer's Complete GuideBuild Safe Multiplayer Chat Systems with AI Moderation

Alan Agon

January 19, 2025 · 9 min read

Implementing effective chat moderation in Unity requires more than just API calls—it demands careful consideration of performance, user experience, and network architecture. This comprehensive guide walks you through building a production-ready chat system with AI-powered moderation that scales with your player base.

Setup Requirements and Dependencies

Before diving into implementation, ensure your Unity project meets these requirements:

Basic API Integration

Let's start with a simple moderation client that can check messages against the Paxmod API:

using System;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using Newtonsoft.Json;

public class PaxmodClient : MonoBehaviour
{
    private const string API_URL = "https://api.paxmod.com/v1/text";
    private string apiKey = "YOUR_API_KEY_HERE";
    
    [System.Serializable]
    public class ModerationRequest
    {
        public string text;
    }
    
    [System.Serializable]
    public class ModerationResponse
    {
        public bool flagged;
        public string reason;
        public float confidence;
        public string[] categories;
    }
    
    public void CheckMessage(string message, System.Action<ModerationResponse> callback)
    {
        StartCoroutine(CheckMessageCoroutine(message, callback));
    }
    
    private IEnumerator CheckMessageCoroutine(string message, System.Action<ModerationResponse> callback)
    {
        var request = new ModerationRequest { text = message };
        string jsonData = JsonConvert.SerializeObject(request);
        
        using (UnityWebRequest www = new UnityWebRequest(API_URL, "POST"))
        {
            byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);
            www.uploadHandler = new UploadHandlerRaw(bodyRaw);
            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Content-Type", "application/json");
            www.SetRequestHeader("Authorization", "Bearer " + apiKey);
            
            yield return www.SendWebRequest();
            
            if (www.result == UnityWebRequest.Result.Success)
            {
                var response = JsonConvert.DeserializeObject<ModerationResponse>(www.downloadHandler.text);
                callback?.Invoke(response);
            }
            else
            {
                Debug.LogError("Moderation API Error: " + www.error);
                callback?.Invoke(null);
            }
        }
    }
}

Building the Complete Chat System

Now let's create a full chat system that integrates seamlessly with our moderation client:

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class ChatManager : MonoBehaviour
{
    [Header("UI References")]
    public TMP_InputField chatInput;
    public TMP_Text chatDisplay;
    public ScrollRect chatScrollRect;
    public Button sendButton;
    
    [Header("Moderation Settings")]
    public PaxmodClient moderationClient;
    public bool enableRealTimeModeration = true;
    public float moderationTimeout = 5f;
    
    private List<string> chatHistory = new List<string>();
    private Queue<string> pendingMessages = new Queue<string>();
    
    void Start()
    {
        sendButton.onClick.AddListener(SendMessage);
        chatInput.onEndEdit.AddListener(OnInputEndEdit);
    }
    
    void OnInputEndEdit(string input)
    {
        if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter))
        {
            SendMessage();
        }
    }
    
    public void SendMessage()
    {
        string message = chatInput.text.Trim();
        if (string.IsNullOrEmpty(message)) return;
        
        chatInput.text = "";
        chatInput.ActivateInputField();
        
        if (enableRealTimeModeration)
        {
            // Show "sending..." state
            AddSystemMessage("Sending message...");
            moderationClient.CheckMessage(message, OnModerationResult);
        }
        else
        {
            // Send immediately without moderation
            BroadcastMessage(message);
        }
    }
    
    private void OnModerationResult(PaxmodClient.ModerationResponse response)
    {
        if (response == null)
        {
            AddSystemMessage("Failed to send message. Please try again.");
            return;
        }
        
        if (response.flagged)
        {
            AddSystemMessage($"Message blocked: {response.reason}");
        }
        else
        {
            BroadcastMessage(pendingMessages.Dequeue());
        }
    }
    
    private void BroadcastMessage(string message)
    {
        string playerName = "Player"; // Get from player data
        string formattedMessage = $"[{System.DateTime.Now:HH:mm}] {playerName}: {message}";
        
        AddChatMessage(formattedMessage);
        
        // Send to other players via networking
        // NetworkManager.instance.SendChatMessage(message);
    }
    
    private void AddChatMessage(string message)
    {
        chatHistory.Add(message);
        UpdateChatDisplay();
    }
    
    private void AddSystemMessage(string message)
    {
        string systemMessage = $"[{System.DateTime.Now:HH:mm}] System: {message}";
        chatHistory.Add(systemMessage);
        UpdateChatDisplay();
    }
    
    private void UpdateChatDisplay()
    {
        chatDisplay.text = string.Join("
", chatHistory);
        Canvas.ForceUpdateCanvases();
        chatScrollRect.verticalNormalizedPosition = 0f;
    }
}

Performance Optimization Strategies

Real-time moderation can impact game performance if not implemented carefully. Here are key optimization techniques:

Multiplayer Networking Considerations

When building multiplayer games, decide where moderation happens: client-side, server-side, or hybrid.

Testing and Deployment Best Practices

// Use Unity's StreamingAssets or external config
public class Config : MonoBehaviour
{
    public static string GetAPIKey()
    {
        #if UNITY_EDITOR
            return "dev_api_key_here";
        #else
            return Environment.GetEnvironmentVariable("PAXMOD_API_KEY") ?? "fallback_key";
        #endif
    }
}