DEV Community: Paxmod

Replacing Perspective API in game chat: Roblox (Luau) and Minecraft (Paper) examples

Paxmod — Mon, 12 Oct 2026 03:19:52 +0000

Perspective was built for news comments, but plenty of game servers ended up using it for chat. It stops working after December 31, 2026, so if your Roblox experience or Minecraft server sends chat to commentanalyzer.googleapis.com, that check goes dark on January 1.

Disclosure: we build Paxmod, a chat moderation API for games, and both examples call it.

Paxmod uses its own format, so this is a code change, not a URL swap. The request is the same on every platform:

POST https://www.paxmod.com/api/v1/text
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{ "message": "where do you live", "user_id": "12345", "context_id": "global" }

Use the www host, because the apex domain redirects. On success you get status: "success", result as "flagged" or "not_flagged", a human-readable reason, and per-category scores under content_moderation.categories. Check status before trusting result. Messages are capped at 5,000 characters, which chat never gets near.

Why game chat is different

Perspective scores each message on its own and knows nothing about who sent it. Two things in game chat need more than that:

Personal information. "where do you live" isn't toxic, so Perspective scored it as fine. In a game full of kids, it's the message you most want to catch. Paxmod has a Personally Identifiable Information category, and the Gaming chat preset turns it on.
Who and where. Send a stable user_id (the player's UserId or UUID) and a context_id (server, world, channel or party) with every message. The Studio plan adds conversation context, which checks a message against that player's recent history instead of on its own.

Roblox (Luau, server-side)

You don't need your own proxy for this. Roblox server scripts can call outside HTTPS APIs through HttpService, and the experience's Secrets store keeps the API key out of your code.

Setup:

In Studio, go to File, Experience Settings, Security and turn on Allow HTTP Requests.
In the Creator Dashboard, open your experience, go to Secrets, and create PAXMOD_API_KEY with the domain www.paxmod.com. Secrets can only go in the URL or headers, never the request body, which is why the key goes in the Authorization header.
Secrets aren't available in local playtests or client scripts. To test in Studio, add the same key under Local Secrets in Experience Settings.

ServerScriptService/PaxmodClient (ModuleScript):

--!strict
local HttpService = game:GetService("HttpService")

local PaxmodClient = {}

local API_URL = "https://www.paxmod.com/api/v1/text"

export type Verdict = { flagged: boolean, reason: string? }

-- Returns a Verdict, or nil if the check couldn't run (you decide what nil means).
function PaxmodClient.moderate(text: string, userId: number, contextId: string): Verdict?
    if text == "" then
        return { flagged = false }
    end

    local ok, response = pcall(function()
        return HttpService:RequestAsync({
            Url = API_URL,
            Method = "POST",
            Headers = {
                ["Content-Type"] = "application/json",
                -- The key never appears in your script or logs.
                ["Authorization"] = HttpService:GetSecret("PAXMOD_API_KEY"):AddPrefix("Bearer "),
            },
            Body = HttpService:JSONEncode({
                message = text,
                user_id = tostring(userId),
                context_id = contextId,
            }),
        })
    end)

    if not ok or not response.Success then
        warn("[Paxmod] check failed:", if ok then response.StatusCode else response)
        return nil
    end

    local decoded = HttpService:JSONDecode(response.Body)
    if decoded.status ~= "success" then
        return nil
    end
    return { flagged = decoded.result == "flagged", reason = decoded.reason }
end

return PaxmodClient

Text players type into your own UI

Pet names, signs, bios and the like are the easy case. The client sends the raw string to the server, and the server checks it before anything is saved. A RemoteFunction handler is allowed to yield, so it can wait for the HTTP call:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local PaxmodClient = require(script.Parent.PaxmodClient)

local setPetName = ReplicatedStorage:WaitForChild("SetPetName") -- a RemoteFunction

setPetName.OnServerInvoke = function(player: Player, name: any)
    if typeof(name) ~= "string" or #name == 0 or #name > 30 then
        return false
    end
    local verdict = PaxmodClient.moderate(name, player.UserId, "pet-names")
    if verdict == nil or verdict.flagged then
        return false -- nothing gets saved, so failing closed is cheap here
    end
    -- Save it, and still run Roblox's TextService filtering before showing it to anyone else.
    return true
end

Chat

For chat, the server-side hook is TextChannel.ShouldDeliverCallback. (OnIncomingMessage only runs on clients.) Roblox's docs say chat callbacks must not yield, so this checks in the background and lets the message through either way (a server Script):

local TextChatService = game:GetService("TextChatService")
local PaxmodClient = require(script.Parent.PaxmodClient)

local general = TextChatService:WaitForChild("TextChannels"):WaitForChild("RBXGeneral")
local seen: { [string]: boolean } = {}

general.ShouldDeliverCallback = function(message: TextChatMessage, _recipient: TextSource)
    -- This runs once per recipient, so only check each message once.
    local id = message.MessageId
    if not seen[id] then
        seen[id] = true
        local source = message.TextSource
        if source then
            -- Don't yield inside the callback. Check in the background.
            task.spawn(function()
                local verdict = PaxmodClient.moderate(message.Text, source.UserId, "RBXGeneral")
                if verdict and verdict.flagged then
                    source.CanSend = false -- mute in this channel
                    task.delay(60, function()
                        if source.Parent then
                            source.CanSend = true
                        end
                    end)
                    -- Log verdict.reason for your moderators here.
                end
                task.delay(30, function()
                    seen[id] = nil
                end)
            end)
        end
    end
    return true
end

Notes:

This acts after the message, not before it. Roblox's own text filter still decides what other players see, and you must keep it. This adds a layer on top that mutes the sender and gives you a log.
Check what the server actually sees. Roblox documents TextChatMessage.Text as the filtered text, and the docs don't spell out whether the server gets it before or after Roblox's filter in this callback. Log a few messages in a live server before you rely on it. If Roblox has already hashed out personal info by the time you see it, this hook won't catch it, so lean on the RemoteFunction pattern for custom text and treat chat checks as a second line.
Rate limits. Each game server can make 500 external HTTP requests per minute. A busy server with chatty players can hit that, and at that point it's worth routing chat through your own backend and batching from there.

Minecraft (Paper, Java 17+)

When a player types a message, Paper fires AsyncChatEvent off the main thread, so a short blocking HTTP call only delays that one message, not the server. If a plugin makes a player chat, the event fires synchronously instead, which is why the listener checks isAsynchronous() first. Gson and Adventure's plain-text serializer both come with the Paper API, so there's nothing extra to shade in.

package com.example.chatguard;

import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import io.papermc.paper.event.player.AsyncChatEvent;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.logging.Logger;

public final class PaxmodChatListener implements Listener {
    private static final URI API = URI.create("https://www.paxmod.com/api/v1/text");

    private final HttpClient http = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(2))
            .build();
    private final String apiKey;
    private final Logger log;

    public PaxmodChatListener(String apiKey, Logger log) {
        this.apiKey = apiKey;
        this.log = log;
    }

    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
    public void onChat(AsyncChatEvent event) {
        // If another plugin fires chat on the main thread, don't block the server.
        if (!event.isAsynchronous()) return;

        // originalMessage() is what the player typed, before other plugins changed it.
        String text = PlainTextComponentSerializer.plainText().serialize(event.originalMessage());
        if (text.isBlank()) return;

        JsonObject body = new JsonObject();
        body.addProperty("message", text);
        body.addProperty("user_id", event.getPlayer().getUniqueId().toString());
        body.addProperty("context_id", event.getPlayer().getWorld().getName());

        HttpRequest request = HttpRequest.newBuilder(API)
                .timeout(Duration.ofSeconds(3))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
                .build();

        try {
            HttpResponse<String> response = http.send(request, HttpResponse.BodyHandlers.ofString());
            JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();

            if (response.statusCode() != 200 || !"success".equals(json.get("status").getAsString())) {
                log.warning("Paxmod check failed with HTTP " + response.statusCode() + ", allowing message");
                return; // fail open, but loudly
            }

            if ("flagged".equals(json.get("result").getAsString())) {
                event.setCancelled(true);
                event.getPlayer().sendMessage(
                        Component.text("Your message was blocked by chat moderation.", NamedTextColor.RED));
                log.info(event.getPlayer().getName() + " blocked: " + json.get("reason").getAsString());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            log.warning("Paxmod check failed (" + e.getMessage() + "), allowing message");
        }
    }
}

String key = getConfig().getString("paxmod-api-key");
getServer().getPluginManager().registerEvents(new PaxmodChatListener(key, getLogger()), this);

If you use a chat plugin like ChatProtect or AutoMod that was set up with Perspective, check its config for a Perspective key. Those plugins call Perspective themselves, so you'll need to turn that part off and use a listener like this one, or check whether the plugin supports another provider. There's a Minecraft-specific write-up on paxmod.com.

Fail open or fail closed?

Both examples let messages through when the check fails, because blocking all chat during an outage is its own disaster. Just don't let it be silent: log every failure and alert when the failure rate climbs. Perspective's shutdown is a good reminder of what happens when a check that fails open goes quiet and nobody notices.

Before you switch

Run both APIs on the same chat while Perspective still works, and compare decisions before you cut over.
Set thresholds per category in the Paxmod console. Perspective thresholds don't carry over.
Delete the Perspective key once you're done.

Paxmod plans start at $29/month for 50,000 messages (Studio is $149/month for 500,000), with a 14-day trial that includes 10,000 messages. A card is needed for the trial and there's no free plan. There's also a Roblox integration page with a ready-made server module.

For the full attribute mapping and before and after code in curl, Node and Python, see the guide: Perspective API alternative: migrate before Dec 31.

Replacing Perspective API in Discourse and Coral Talk before Dec 31

Paxmod — Sat, 10 Oct 2026 03:16:34 +0000

Two of the most common places Perspective API hides are a Discourse forum running the official discourse-perspective-api plugin, and a Coral Talk comment section with the toxicity filter turned on. Perspective stops working after December 31, 2026, and neither of these will tell you loudly when it does.

Disclosure: we build Paxmod, a moderation API, and the code below calls it. The parts about how Discourse and Coral behave come from reading their source and apply whatever you switch to.

One thing up front: Paxmod has its own request and response format, and there's no Paxmod plugin for Discourse. So this isn't a "change the URL" job. It's a small amount of glue code, and below is all of it.

What each one does today

Discourse plugin (discourse/discourse-perspective-api, MIT licensed):

The Google host is a constant in lib/discourse_perspective.rb. There's no setting to change it.
On post_created and post_edited it queues a job that sends the post to Perspective, asking for TOXICITY (or SEVERE_TOXICITY if you picked the experimental model).
If the score is above perspective_flag_post_min_toxicity (default 0.9), it flags the post for moderators as the system user.
Optionally it checks the composer before posting and warns the user above 0.85, and it can backfill old posts every 10 minutes.

The part that matters for January: the plugin parses the response, and if there's no attributeScores in it (which is what an HTTP error body looks like), the score quietly becomes 0.0. Only connection-level failures raise an error. So if Perspective starts answering with an error, every post scores as clean and nothing gets flagged. If backfill is on, it also writes 0.0 into the stored scores.

Coral Talk:

Coral lets admins set a custom Perspective endpoint, key, model and threshold. It appends /comments:analyze and ?key= to whatever endpoint you give it.
It reads attributeScores[model].summaryScore.value and withholds the comment for review if the score is above the threshold.
If the call fails, Coral logs "could not determine comment toxicity" and the comment goes through unflagged.

That configurable endpoint only helps if the replacement speaks Perspective's exact format. Paxmod doesn't, so for Coral we use a different, better hook: external moderation phases.

The shared bit: one function that calls Paxmod

Both integrations below use this. Node 18+, no dependencies.

// paxmod.js
const PAXMOD_URL = "https://www.paxmod.com/api/v1/text";
const MAX_CHARS = 4900; // the API rejects anything over 5,000 characters

export async function moderate(text, { userId, contextId }) {
  if (!text || !text.trim()) return { flagged: false }; // the API rejects empty messages

  // Long forum posts get split, and the post is flagged if any part is.
  const chunks = [];
  for (let i = 0; i < text.length; i += MAX_CHARS) chunks.push(text.slice(i, i + MAX_CHARS));

  for (const chunk of chunks) {
    const res = await fetch(PAXMOD_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${process.env.PAXMOD_API_KEY}`,
      },
      body: JSON.stringify({ message: chunk, user_id: String(userId), context_id: contextId }),
      signal: AbortSignal.timeout(3000),
    });
    const data = await res.json();

    // Check status first. Some error bodies also contain result: "not_flagged".
    if (!res.ok || data.status !== "success") {
      throw new Error(`Paxmod error ${res.status}: ${data?.error?.code ?? "unknown"}`);
    }
    if (data.result === "flagged") return { flagged: true, reason: data.reason };
  }
  return { flagged: false };
}

Each chunk is a separate call, so a 12,000-character post costs three. If that bothers you, moderate the first chunk only.

Discourse, option A: a webhook (no fork)

This leaves Discourse untouched. Disable the Perspective plugin, then on the admin webhooks page (/admin/api/web_hooks) add a webhook that sends Post events as application/json to your service, with a secret. Discourse sends the post under a post key, including raw, user_id and topic_id, names the event in an X-Discourse-Event header (post_created, post_edited and so on), and signs the body in X-Discourse-Event-Signature.

You also need an API key to file the flag. On /admin/api/keys, either create a key for a single staff account, or create an "All users" key and pick the acting account with the Api-Username header, as below.

// server.js
import express from "express";
import crypto from "node:crypto";
import { moderate } from "./paxmod.js";

const app = express();
app.use(express.json({ verify: (req, _res, buf) => { req.rawBody = buf; } }));

function validSignature(rawBody, header, secret) {
  const expected = "sha256=" + crypto.createHmac("sha256", secret).update(rawBody).digest("hex");
  return header && header.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(header), Buffer.from(expected));
}

app.post("/discourse", async (req, res) => {
  if (!validSignature(req.rawBody, req.get("X-Discourse-Event-Signature"), process.env.DISCOURSE_WEBHOOK_SECRET)) {
    return res.sendStatus(401);
  }
  res.sendStatus(200); // answer Discourse fast, moderate after

  const event = req.get("X-Discourse-Event");
  const post = req.body.post;
  if (!post || !["post_created", "post_edited"].includes(event)) return;

  try {
    const verdict = await moderate(post.raw, { userId: post.user_id, contextId: `topic_${post.topic_id}` });
    if (!verdict.flagged) return;

    // Default flag type ids: 3 off_topic, 4 inappropriate, 7 notify_moderators, 8 spam.
    // notify_moderators requires a message.
    await fetch(`${process.env.DISCOURSE_URL}/post_actions.json`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Api-Key": process.env.DISCOURSE_API_KEY,
        "Api-Username": "system", // needed for an "All users" key, optional for a single-user key
      },
      body: JSON.stringify({ id: post.id, post_action_type_id: 7, message: `Paxmod: ${verdict.reason}` }),
    });
  } catch (err) {
    // Don't swallow this. A failed check should page someone, not look like a clean post.
    console.error("moderation failed for post", post.id, err);
  }
});

If you'd rather treat it like a member's flag, use 4 (inappropriate) instead. That's one of the flag types that can feed Discourse's automatic hiding, while notify_moderators doesn't count toward it. Either way you lose the composer warning, but you gain an error you can actually see.

Discourse, option B: fork the plugin

If you'd rather keep the plugin's flow (composer check, backfill, settings), fork it. It's MIT, so keep the licence and copyright notice. The whole change is the score_comment method in lib/discourse_perspective.rb:

PAXMOD_URL = "https://www.paxmod.com/api/v1/text"

def self.score_comment(post)
  # The composer check passes a User object here, posts pass an id.
  uid = post&.user_id
  uid = uid.id if uid.respond_to?(:id)

  response = Excon.post(
    PAXMOD_URL,
    headers: {
      "Content-Type" => "application/json",
      # Reusing the existing setting to hold the Paxmod key. Rename it in your fork.
      "Authorization" => "Bearer #{SiteSetting.perspective_google_api_key}",
    },
    body: { message: post.raw.to_s[0, 4900], user_id: uid.to_s, context_id: "discourse" }.to_json,
    connect_timeout: 1,
    read_timeout: 3,
    write_timeout: 3,
  )

  data = (MultiJson.load(response.body) rescue {}) || {}
  if response.status != 200 || data["status"] != "success"
    # Raise instead of returning 0.0, so jobs retry and the failure shows in logs.
    raise NetworkError, "Paxmod returned #{response.status} #{data.dig("error", "code")}"
  end

  categories = data.dig("content_moderation", "categories") || {}
  top = categories.values.map { |c| c["score"].to_f }.max || 0.0
  { score: data["result"] == "flagged" ? 1.0 : top }
end

Two things to know:

Flagged posts come back as 1.0, so the plugin's 0.9 threshold flags them. The real thresholds now live per category in the Paxmod console, so tune them there, not in Discourse.
This version opens a new connection per call and drops the old mutex and connection reuse. Fine for most forums. Add it back if you post a lot.

Coral: an external moderation phase

Coral can call your own HTTPS endpoint on every new or edited comment and let you decide what happens. Turn off the Perspective toxicity filter, then go to Configure, Moderation Phases in Coral's admin, add an external moderation phase with your service as the Callback URL, and copy its signing secret.

Raise the timeout. It defaults to 200 ms, and if your service doesn't answer in time Coral skips the phase and the comment carries on. Set it to about 3,500 ms (the field allows 100 to 10,000), a little above the 3-second timeout in moderate().

Coral signs the body with HMAC-SHA256 and sends X-Coral-Signature: sha256=<hex> (comma-separated if more than one secret is active).

app.post("/coral", async (req, res) => {
  const header = req.get("X-Coral-Signature") || "";
  const expected = "sha256=" + crypto.createHmac("sha256", process.env.CORAL_SIGNING_SECRET).update(req.rawBody).digest("hex");
  if (!header.split(",").includes(expected)) return res.sendStatus(401);

  const { comment, author, story } = req.body;
  try {
    const verdict = await moderate(comment.body, { userId: author.id, contextId: story.id });
    if (!verdict.flagged) return res.sendStatus(204); // no opinion, carry on

    // Same outcome as Coral's built-in toxicity filter: hold it and flag it.
    return res.json({
      status: "SYSTEM_WITHHELD",
      actions: [{ actionType: "FLAG", reason: "COMMENT_DETECTED_TOXIC" }],
    });
  } catch (err) {
    console.error("moderation failed", err);
    // Your call. PREMOD holds it for a human. Returning 204 lets it through.
    return res.json({ status: "PREMOD" });
  }
});

Set Comment Body Format to Plain Text so comment.body has the HTML stripped. This is better than the Perspective filter in one way: when the moderation call fails, you decide whether comments wait for a human or go live. With the built-in filter, they just go live. (A Coral-side timeout still lets the comment through, which is why the timeout setting matters.)

Before you cut over

Run both side by side while Perspective still answers. Log Perspective's score and Paxmod's decision for the same posts for a week or two, then set Paxmod's category thresholds from what you see.
Check what your forum actually needs. Paxmod can also flag personal information like "what's your address" if you turn on that category, which is something Perspective never scored.
Turn off backfill in the Discourse plugin before Jan 1 if you keep it, or it'll keep writing scores from failed calls.

Paxmod plans start at $29/month for 50,000 messages (Studio is $149/month for 500,000), with a 14-day trial that includes 10,000 messages. A card is needed for the trial and there's no free plan.

The general migration guide, with the full attribute mapping and before and after code, is here: Perspective API alternative: migrate before Dec 31.

Perspective API shuts down Dec 31: what breaks on January 1

Paxmod — Thu, 08 Oct 2026 05:16:20 +0000

Google's Perspective API stops working after December 31, 2026. Jigsaw stopped taking usage and quota-increase requests after February 2026, so whatever quota you have now is what you'll have until the end. The default is an average of 1 query per second per project.

The shutdown itself is easy to understand. The dangerous part is what your code does when the call stops working, because a lot of moderation code is written to never get in the user's way. When that code fails, it lets everything through and doesn't tell anyone.

Disclosure: we build Paxmod, a moderation API, and we mention it at the end. Everything else here applies whatever you replace Perspective with.

1. Assume it fails quietly

We don't know exactly what commentanalyzer.googleapis.com will return on January 1. It could be an HTTP error, a timeout or a DNS failure. Your code has to treat all three as "moderation is down", not "this comment is fine".

Here's what two popular integrations do today, from reading their source:

Discourse's official plugin turns any response without attributeScores into a score of 0.0. An HTTP error body has no scores, so every post looks clean and nothing gets flagged. Only connection failures raise an error. If you have backfill on, it also stores those 0.0 scores against old posts.
Coral Talk logs "could not determine comment toxicity" and lets the comment through unflagged.

Your own code probably has the same habit. Look for patterns like these:

const score = data?.attributeScores?.TOXICITY?.summaryScore?.value ?? 0;

try:
    score = analyze(text)
except Exception:
    score = 0.0

Both of these turn an outage into an "everything is clean" result. Make the failure explicit instead:

if (!res.ok || !data.attributeScores) {
  metrics.increment("moderation.failed");
  throw new ModerationUnavailable(res.status);
}

Then decide on purpose, for each surface, whether a failed check lets the message through, holds it for review, or blocks it. Live game chat usually allows it and logs. A kids' platform or a comment section with legal exposure might hold it.

2. Rehearse January 1 now

You don't have to wait. In staging, make Perspective unreachable and watch what happens:

# Option A: break DNS for the host (staging box only)
echo "127.0.0.1 commentanalyzer.googleapis.com" | sudo tee -a /etc/hosts

# Option B: swap in a bad key, which gives you an error body instead of a dead host
export PERSPECTIVE_API_KEY=invalid

Then post something nasty and check:

[ ] Did anything get flagged, held or logged?
[ ] Did an alert fire?
[ ] Did the service still start? If you build a Google API client at startup with googleapiclient.discovery.build("commentanalyzer", ...), that call fetches Perspective's discovery document over the network (the Python client doesn't ship a copy for this API), so it can fail before your app handles a single request.
[ ] Did a queue or retry loop start hammering the API?

Undo the change afterwards.

3. Find every call site

Perspective tends to show up in more places than the one service you remember.

Code and config:

rg -n -i "commentanalyzer|perspectiveapi|comments:analyze|suggestscore|PERSPECTIVE_API" .
rg -n "perspective-api-client|google-api-python-client|peRspective" \
  package.json package-lock.json yarn.lock pnpm-lock.yaml requirements*.txt pyproject.toml poetry.lock DESCRIPTION 2>/dev/null
rg -n -i "perspective" .env* *.tf *.yaml *.yml 2>/dev/null

Across your GitHub org:

gh search code "commentanalyzer" --owner YOUR_ORG
gh search code "perspectiveapi" --owner YOUR_ORG

In Google Cloud. The API is enabled per project, so this lists every project that can still call it:

for p in $(gcloud projects list --format="value(projectId)"); do
  gcloud services list --enabled --project "$p" --format="value(config.name)" \
    | grep -q commentanalyzer && echo "$p"
done

Then check the traffic graph for each one in the console under APIs and Services. If a project shows traffic you can't explain, something you forgot is still calling it.

In apps you didn't write. These keep their Perspective settings in the app, not in your repo:

Discourse: the discourse-perspective-api plugin, with its key in site settings.
Coral Talk: Configure, Moderation, the Perspective toxicity filter.
Minecraft servers: chat plugins like ChatProtect and AutoMod can be set up to use Perspective.
Discord and Telegram bots, browser extensions, and research notebooks (the peRspective R package is common in academic work).

4. List what you'll lose

Write down exactly what you use, because a replacement won't match it one for one:

Attributes. The production ones were TOXICITY, SEVERE_TOXICITY, IDENTITY_ATTACK, INSULT, PROFANITY and THREAT, and SEXUALLY_EXPLICIT and FLIRTATION were experimental (English only). Note which ones you request and which ones you actually act on.
Thresholds. A 0.8 from Perspective doesn't mean 0.8 anywhere else. Every threshold has to be re-tuned.
Span scores. If you highlight the offending part of a comment, you're using spanScores, and most replacements don't return them.
Languages. Check which languages your traffic is actually in, not which ones you configured.
Stored scores. Dashboards, trust levels and "toxicity over time" charts built on stored scores will flatline, or worse, fill with zeros from failed calls.
Feedback. If you send moderator decisions back with comments:suggestscore (Coral's "send feedback" option does this), that loop ends too.

5. Shadow-run before you switch

This is the step that makes the cutover boring. It only works while Perspective is still answering, so it has to happen before December 31.

Wrap your moderation call so it sends each message to Perspective and to the replacement. Keep acting on Perspective's answer.
Log both results, plus how long each took and whether either one errored.
Because you can't get more quota, sample traffic if you're near your limit (on the default 1 QPS, that means sampling). A few thousand real messages is enough to compare.
Review the cases where they disagree. That's where you set the new thresholds, and where you find out what the replacement catches that Perspective didn't.
Switch which answer you act on, keep logging both for a few days, then remove Perspective and delete the key.

Aim to finish well before the holidays. Nobody wants to debug moderation on December 31.

Where Paxmod fits

If you're choosing a replacement, Paxmod is built for real-time chat and comments. It takes one call per message with a user_id and context_id, returns a flagged or not_flagged decision with per-category scores, and catches personal information like "where do you live", which Perspective never scored. It has its own format, so you'll change the request and response code, not just the URL. Plans start at $29/month for 50,000 messages, with a 14-day trial that includes 10,000 messages (card required, no free plan).

The step-by-step migration, with the attribute mapping and before and after code, is in our guide: Perspective API alternative: migrate before Dec 31.

Perspective API alternative: how to migrate before the Dec 31 shutdown (with code)

Paxmod — Thu, 08 Oct 2026 04:51:40 +0000

Google's Perspective API stops working after December 31, 2026. Jigsaw closed usage and quota requests in February 2026 and isn't offering migration support. If your forum, comment section or game chat calls commentanalyzer.googleapis.com, that call starts failing on January 1.

Disclosure: we build Paxmod, a content moderation API for real-time chat, so this guide migrates you to Paxmod. The checklist at the end works whichever API you pick.

Short version

Paxmod isn't a drop-in clone of Perspective. The request and response look different. But in most codebases the switch is one function:

	Perspective	Paxmod
Endpoint	`POST https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze`	`POST https://www.paxmod.com/api/v1/text`
Auth	`?key=KEY` query param	`Authorization: Bearer KEY` header
Text field	`comment.text`	`message`
Who and where	`sessionId` (optional)	`user_id` and `context_id` (optional, recommended)
Attributes	`requestedAttributes` on every request	Categories and thresholds set per project in the console
Score you read	`attributeScores.TOXICITY.summaryScore.value`	`content_moderation.categories["Harassment"].score`
Decision	You compare scores to thresholds	`result` is `"flagged"` or `"not_flagged"`
Max length	20 KB	5,000 characters (split longer text)

Use the www host. The apex domain redirects, and plenty of POST clients won't follow it.

Mapping Perspective attributes to Paxmod categories

Perspective	Paxmod	Notes
TOXICITY	Harassment, Hate and Discrimination, Profanities	Take the highest, or just use `result`
SEVERE_TOXICITY	Threatening, Violence, Hate and Discrimination	Take the highest
IDENTITY_ATTACK	Hate and Discrimination	Direct match
INSULT	Harassment	Harassment is a little broader
THREAT	Threatening, Violence	Take the highest
PROFANITY	Profanities	Dictionary matcher: 0.8 on a match, 0 otherwise, so keep the threshold below 0.8
SEXUALLY_EXPLICIT	Sexual	Direct match
FLIRTATION	none fixed	Write it as a plain-English rule in Advanced mode

Don't copy your thresholds across. Paxmod's scores come from different models, so a 0.8 in Perspective isn't a 0.8 in Paxmod. Each category has its own threshold (default 0.5, flagged when the score goes above it).

Before and after: curl

Before:

curl -X POST \
  "https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze?key=$PERSPECTIVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "comment": { "text": "you are trash, uninstall" },
    "languages": ["en"],
    "requestedAttributes": { "TOXICITY": {}, "INSULT": {}, "THREAT": {} }
  }'

After:

curl -X POST "https://www.paxmod.com/api/v1/text" \
  -H "Authorization: Bearer $PAXMOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "you are trash, uninstall",
    "user_id": "player_123",
    "context_id": "lobby_7"
  }'

Before and after: Node

Before:

const res = await fetch(
  `https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze?key=${process.env.PERSPECTIVE_API_KEY}`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      comment: { text },
      languages: ["en"],
      requestedAttributes: { TOXICITY: {} },
    }),
  }
);
const data = await res.json();
const isToxic = data.attributeScores.TOXICITY.summaryScore.value > 0.8;

After:

const res = await fetch("https://www.paxmod.com/api/v1/text", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.PAXMOD_API_KEY}`,
  },
  body: JSON.stringify({ message: text, user_id: userId, context_id: channelId }),
});
const data = await res.json();
if (data.status === "error") throw new Error(data.error.code);

const isToxic = data.result === "flagged";
const harassment = data.content_moderation.categories["Harassment"]?.score ?? 0;

Before and after: Python

Before:

import os, requests

r = requests.post(
    "https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze",
    params={"key": os.environ["PERSPECTIVE_API_KEY"]},
    json={
        "comment": {"text": text},
        "languages": ["en"],
        "requestedAttributes": {"TOXICITY": {}},
    },
    timeout=5,
)
is_toxic = r.json()["attributeScores"]["TOXICITY"]["summaryScore"]["value"] > 0.8

After:

import os, requests

r = requests.post(
    "https://www.paxmod.com/api/v1/text",
    headers={"Authorization": f"Bearer {os.environ['PAXMOD_API_KEY']}"},
    json={"message": text, "user_id": user_id, "context_id": channel_id},
    timeout=5,
)
data = r.json()
is_toxic = data.get("result") == "flagged"

What the Paxmod response looks like

Example values. You get back the categories enabled on your project:

{
  "status": "success",
  "id": "5f0c2a8e-1d9b-4c47-9a51-3c1f6f2b7e10",
  "service": "pax",
  "request": {
    "original_message": "you are trash, uninstall",
    "processed_message": "you are trash, uninstall",
    "timestamp": "2026-10-08T02:00:00.000Z"
  },
  "result": "flagged",
  "reason": "Content flagged for Harassment",
  "degraded": false,
  "unavailable_categories": [],
  "content_moderation": {
    "flagged": true,
    "categories": {
      "Harassment": { "flagged": true, "threshold": 0.5, "score": 0.93 },
      "Threatening": { "flagged": false, "threshold": 0.5, "score": 0.04 },
      "Personally Identifiable Information": { "flagged": false, "threshold": 0.5, "score": 0.01 }
    }
  }
}

result is flagged when any enabled category goes above its threshold, and reason names which ones.
degraded: true means an upstream classifier was briefly unavailable, and the categories listed in unavailable_categories weren't scored on that call.
Errors look like {"status": "error", "error": {"code": "INVALID_API_KEY", ...}}.

The 6-step migration plan

Start a trial and create a project. Copy the API key.
Turn on the categories that match the Perspective attributes you used. For game chat, start with the Gaming chat preset.
Swap the request: new URL, Bearer header, message plus user_id and context_id.
Swap the parsing: read content_moderation.categories[...], or act on result.
Shadow-run until December 31. Send the same messages to both APIs, compare decisions on real traffic, and set thresholds from that. This is the step people skip, and it only works while Perspective is still answering.
Cut over and delete the Perspective key before January 1, 2027.

What Perspective never did

Personal information. "where do you live" gets flagged under Personally Identifiable Information. Perspective had no attribute for that, and in kids' game chat it matters more than swearing.
Game chat. Paxmod runs on custom Minecraft servers and Roblox games, with a Roblox module and a Unity integration. If you run a Minecraft plugin that used Perspective (ChatProtect and AutoMod both can), there's a Minecraft-specific guide.
Player-aware moderation. Each message carries a user_id and a context_id. The Studio plan adds conversation context, which checks a message against the player's recent history instead of on its own.
Your own rules. Advanced mode checks messages against a policy you write in plain English.
Harder to dodge. Text is normalised before scoring, including Unicode lookalike characters and hidden zero-width characters.

What it costs

Perspective was free, and Paxmod isn't. Indie is $29/month with 50,000 message credits, and Studio is $149/month with 500,000. Every plan starts with a 14-day free trial that includes 10,000 messages and every feature. Full details are on the pricing page.

Checklist, whatever API you pick

[ ] Find every call to commentanalyzer.googleapis.com (code, plugins, config).
[ ] Note which attributes and thresholds each one uses.
[ ] Check how your code handles errors. Plenty of integrations treat a failed call as "clean", so moderation can quietly stop on January 1.
[ ] Shadow-run the replacement while Perspective still works.
[ ] Cut over before December 31.

The full guide, with the mapping table and FAQ, is on paxmod.com.

Community Sift Is Sunsetting: Use Paxmod for Unity and Roblox Chat Moderation (2026)

Paxmod — Sat, 26 Sep 2026 04:37:26 +0000

Community Sift (and Indie Sift) is sunsetting. If your studio still routes live game chat through it, you need a replacement on the critical path, not a six-week enterprise RFP.

For Unity, Roblox, and custom multiplayer chat, use Paxmod. It is a self-serve game chat moderation API built for live lobbies, party chat, and COPPA-shaped risk. Get a key the same day, wire moderate-on-submit, keep Roblox TextFilter as a first layer, and stop waiting on sales-gated filters.

This post is from the Paxmod team. We built the product for this exact migration. Below is why studios pick us over GGWP, Azure AI Content Safety, OpenAI Moderation, and other "Sift alternative" lists, plus the afternoon checklist to prove it on your own sample.

What your Sift replacement actually has to do

Sift won gaming trust and safety on three things: chat-tuned text classification, policy around the score, and someone to call when production broke. Those criteria still matter. The market around them changed:

Azure Content Moderator is also retiring (Microsoft points teams to Azure AI Content Safety, sunset 15 March 2027). Microsoft stacks get a second forced move.
Indie and mid-size teams cannot wait on custom pricing when chat is in the match loop.
Kids and mixed-age titles need PII detection and grooming-risk signals, not only a toxicity label.
On Roblox, TextFilter / TextChatService is mandatory. Anything that claims to replace Roblox filtering is the wrong architecture. You want a second layer on top.

So you are not shopping for "any moderation API." You are shopping for a game chat moderation API that replaces Sift-shaped workflows without freezing chat.

Why Paxmod is the default pick after Sift

Paxmod is API-first trust and safety with gaming as the beachhead. Live multiplayer chat is the product, not a general comment filter bolted onto games later.

What that means in practice:

Hot-path REST (and WebSocket) aimed at ~500ms responses so moderation does not stall match flow
Gaming-trained classifiers for slang, evasion, and lobby/party policy categories
COPPA-oriented tooling on every plan: PII detection, stricter age thresholds, grooming-risk scoring (research collaboration with the Australian Institute for Machine Learning). Compliance stays your legal call; the API is the technical layer. Details: COPPA chat moderation
Roblox as a layer, not a replacement: keep TextFilter; add Paxmod for grooming patterns, PII, and custom policy. Guide: Roblox chat moderation
Unity path for server-side moderate-on-submit: Unity chat moderation
Public pricing, same-day key: Standard $0.25 per 1,000 messages, Advanced $0.40 per 1,000, free tier to test. Pricing

Production shape from one live multiplayer client (kids-oriented chat, 30 days ending 13 September 2026), published as the Game Chat Index:

12.8M+ messages scanned
1.04% flag rate
Largest flag share suggestive/sexual (33.2%), then kids-adjacent and PII, not only slurs
Client-reported 87% toxicity reduction under its live policy

That mix is why a free general moderation endpoint often fails week one: it over-mutes banter and under-weights contact-seeking and grooming-adjacent patterns.

Full matrix (Paxmod vs GGWP vs Azure AI Content Safety vs Hive): Gaming moderation API comparison 2026.

How the other options compare (and when they are wrong for you)

Option	What it is good at	Why it is usually the wrong Sift swap for Unity/Roblox chat
Paxmod	Self-serve game chat API, Unity/Roblox paths, COPPA-oriented tools, public price	This is the path we recommend for indie to mid-size multiplayer
GGWP	Large T&S orgs that want reputation, voice, reports, ops dashboards	Sales-gated and heavy. Fine if you are buying a full platform and have budget/time. Overkill if you need an API this month
Azure AI Content Safety	Azure-centric stacks leaving Content Moderator	General-purpose. Not COPPA-optimized. Gaming slang false positives are common
Lasso	Broad content API (text/image/video) and Sift-shaped migration docs	Verify kids-safety depth and gaming chat latency before you bet the lobby on it
OpenAI Moderation / Perspective	Prototypes and non-game UGC	Weak on gaming banter. No kids stack. Not a Sift replacement

If you are an enterprise buying a full reputation suite with a large human ops room on day one, talk to GGWP-shaped platforms. If you are all-in on Azure SLAs above gaming-specific accuracy, stay on Azure unless kids-safety forces a split. Everyone else migrating off Sift for live Unity or Roblox chat: start with Paxmod.

Migration checklist (one afternoon + one week)

Afternoon (prove it on your data)

Export 500–2,000 recent chat messages (redact user IDs).
Score the same sample on your current Sift (or interim) path and on Paxmod.
Measure three things only: missed severe harm, false mutes on banter, p50 latency.
If you have under-13 audiences, force-test PII prompts ("what's your Discord / phone") and multi-turn grooming-adjacent patterns.
Confirm fail-open: on timeout, allow the message and log. Never hard-block the whole channel.

Week (ship)

Create a project and API key in the Paxmod console.
Wire server-side moderate-on-submit for one chat surface (global or party).
Map Sift-style severity buckets to warn / mute / escalate actions you already run.
Keep Roblox TextFilter if you are on Roblox. Add Paxmod after it.
Mirror thresholds into staging, then promote.
Keep a human review queue for edge categories for the first two weeks.

You do not need a perfect taxonomy on day one. You need a hot-path decision and a log.

Start here

Get a key and wire one chat surface: Game chat moderation API
Compare vendors on paper: Content moderation API comparison
See live flag mix: Game Chat Index
Roblox layering: Roblox integration
Kids-oriented controls: COPPA

Community Sift is leaving. Paxmod is the replacement we built for Unity and Roblox chat. Run the sample test, then ship.

Best Moderation API for Unity and Roblox Chat (2026): OpenAI Moderation Alternatives That Actually Fit Games

Paxmod — Thu, 24 Sep 2026 04:40:30 +0000

If you ship multiplayer chat in Unity or Roblox, moderation is not a nice-to-have. It is retention, app-store risk, and (for younger audiences) a COPPA-shaped product requirement.

Most teams start with whatever is free and fast to wire: OpenAI Moderation, Perspective API, or a general cloud content-safety endpoint. That gets a demo green. It often fails the first week of live traffic.

This guide is a buyer checklist for production game chat. It covers what breaks with generic tools, what to demand from a vendor, how Paxmod fits those criteria, and a short comparison table.

Primary CTA: Start in the Paxmod console

The problem: game chat is not comment-section toxicity

Game chat mixes trash talk, slang, rapid-fire pings, multilingual abuse, and (in kids-oriented titles) attempts to exchange contact info. A single-message "toxicity score" is a blunt instrument.

In production data from one live multiplayer gaming client (Paxmod Game Chat Index, 30 days ending 13 September 2026):

12.8M+ messages scanned
1.04% flag rate
Largest flag share was suggestive/sexual (33.2%), then kids-adjacent and PII, not just slurs
That client measured 87% toxicity reduction under its live policy

That mix is why "drop in OpenAI Moderation and ship" underperforms. Your false-positive rate on harmless trash talk climbs, while grooming-adjacent patterns and PII slips get under-weighted.

What breaks with OpenAI Moderation and generic tools

1. Gaming slang looks like severity

OpenAI Moderation and similar general-purpose classifiers are strong on clear hate and sexual content. They are weaker at separating competitive banter from harassment in context. Studios then either:

raise thresholds and miss real harm, or
lower thresholds and mute players who were just trash-talking after a round

Either outcome burns player trust.

2. Latency and fail behavior matter in the hot path

Chat sits on the critical path. If moderation adds multi-second delay, players feel it. If the API times out and you fail closed, you brick chat. If you fail open with no logging, you fly blind.

Paxmod is built for real-time game chat with ~500ms responses and documented fail-open patterns on integrations like Roblox (Roblox TextFilter still runs; Paxmod layers on top).

3. Kids products need more than a toxicity label

COPPA-oriented games need PII detection, age-appropriate thresholds, and grooming-risk signals. A free moderation endpoint that returns "sexual / hate / violence" scores is not a kids-safety stack.

Paxmod ships COPPA-oriented tooling (PII detection, configurable thresholds, grooming-risk scoring developed with the Australian Institute for Machine Learning). Details: COPPA chat moderation. Compliance remains your legal call; the API is the technical layer.

4. Roblox already has a mandatory filter

On Roblox, TextFilter / TextChatService is required. Replacing it is the wrong architecture. You want a second layer for grooming patterns, PII, and custom policy that the baseline filter will not catch. Paxmod is designed as that layer, not a replacement.

5. Sales-gated enterprise platforms slow indie and mid-size studios

Some gaming T&S platforms are excellent for large ops teams and are sales-gated with custom pricing. If you need to wire an API this week, transparent self-serve pricing matters.

Buyer criteria checklist

Use this when you evaluate any moderation API for Unity or Roblox chat:

Gaming-aware models (slang, trash talk vs harassment), not only general web toxicity
Real-time latency suitable for chat (target sub-second; Paxmod targets ~500ms)
Fail-open guidance so an outage does not freeze chat
PII and grooming-risk for younger audiences, with configurable thresholds
Unity and Roblox paths (SDKs, server modules, or clear REST examples)
Self-serve + public pricing so you are not blocked on a sales cycle
Human review / queue for edge cases, not scores alone
Auditability (logged decisions you can show to trust & safety or compliance)
Regional / security posture (encryption, GDPR-ready processes; Paxmod states SOC 2 Type II)
Clear migration story if you are leaving Community Sift / Indie Sift or Azure Content Moderator (Azure Content Moderator retires 15 March 2027)

If a vendor fails half of these, keep looking.

How Paxmod fits

Paxmod is an API-first trust & safety stack with gaming as the beachhead: real-time chat moderation for Unity, Roblox, and other multiplayer titles, with the same infrastructure usable later for social, marketplaces, and forums.

What you get in practice:

REST API you can call from game servers; Unity and Roblox integration paths documented
~500ms moderation for chat-scale traffic
Text (and broader media) detection across toxicity, spam, CSAM, PII, and custom categories
COPPA-oriented controls without a separate "COPPA plan"
Usage pricing: Standard $0.25 per 1,000 messages, Advanced $0.40 per 1,000 messages, free tier to test (100 messages/month)
Console for keys, testing, analytics, and review workflows: open the console

Deep dive comparison (Paxmod vs GGWP vs Azure AI Content Safety vs Hive): Gaming moderation API comparison 2026.

Production category mix and volumes: Game Chat Index.

Short comparison table

Criteria	OpenAI Moderation / Perspective	Azure AI Content Safety	Sales-gated gaming T&S platforms	Paxmod
Gaming-trained context	General-purpose	General-purpose	Usually yes	Yes (gaming-native beachhead)
Self-serve + public price	Free / usage	Azure billing	Often sales-gated	Yes ($0.25-$0.40 / 1K)
Unity / Roblox focus	DIY	DIY	Varies	Documented integrations
COPPA-oriented tools	Limited	Not kids-optimized	Varies	PII, thresholds, grooming-risk
Real-time chat design	Possible	Possible	Ops-heavy	~500ms API + fail-open patterns
Best for	Prototypes, non-game UGC	Azure-centric stacks	Large T&S orgs	Indie to mid-size game studios

OpenAI Moderation remains useful for prototypes and non-game UGC. For live Unity/Roblox chat with younger players, a gaming-native API usually wins on false positives, kids-safety signals, and time-to-integrate.

Recommended evaluation path (one afternoon)

List your chat surfaces (global chat, party, DMs, Roblox TextChat channels).
Pull 500-2,000 real recent messages (redact user IDs). Score them with your current tool and with Paxmod side by side.
Measure three things only: missed severe harm, false mutes on banter, and p50 latency.
If you have under-13 audiences, force-test PII prompts ("what's your Discord / phone") and grooming-adjacent multi-turn patterns.
Wire fail-open: on timeout, allow message + log; never hard-block the whole chat channel.
Decide pricing against expected messages/day using pricing.

When not to choose Paxmod

Be honest with your stack:

You need a full enterprise reputation suite and a large human ops room on day one (some platforms optimize for that workflow).
You are all-in on Azure and want Microsoft SLAs above gaming-specific accuracy.
Your only need is occasional comment moderation on a marketing site (a free general API may be enough).

For live game chat, especially Unity or Roblox with COPPA-shaped risk, start with a gaming-native API.

CTA: try it on your traffic

Create a project and API key in the console: https://www.paxmod.com/console?utm_source=devto&utm_medium=parasite&utm_campaign=game_chat_mod_api_2026
Read the full vendor matrix: Content moderation API comparison guide
Inspect live production flag mix:

Game Chat Index
Roblox layering notes: Roblox integration
Kids-oriented controls: COPPA

Paxmod is built so engineering can ship moderation without waiting on a sales call. Open the console, send your first messages, and keep the checklist above as your go / no-go.

Paxmod