Introduction

VoicePatrol moderates voice chat in multiplayer games in real time. The Unity SDK detects speech on the player's device, uploads only speech, and returns moderation results to your game within seconds. Every event also appears on your dashboard.

What's new in 3.1

• Display names: the name other players see is shown with every event on the dashboard, in results and in webhooks.
• Rooms: OnJoinedRoom sets the room shown with each event, and OnLeftRoom now clears it.
• Severity names: severities are now Low, High and Critical (formerly Medium, High and Severe). Their values are unchanged.
• Player reports can include the display name the reporter saw for the offender.
• SetMetadata and the useCdn parameter have been removed. See Upgrading to 3.1 below.

Real-time Voice Moderation

Automatically detect hate, threats, sexual content, harassment and other harmful speech, and act on it in game.

Player Reporting

Let players report others, with the last 2 minutes of audio as evidence for review on your dashboard.

Age Verification

Optionally estimate a player's age range from their first 60 seconds of speech.

Works With Your Voice Chat

Ready-made prefabs for Photon Voice and Vivox, a server-to-server mode where your voice provider sends the audio, and PushAudio for any other voice engine.

Installation & Setup

Requirements

• Unity 2022.3 or later
• Windows x64 and x86
• macOS 10.15 or later on Intel, and 11 or later on Apple silicon (one universal library)
• Linux x64 with glibc 2.34 or later
• Android arm64-v8a and armeabi-v7a, API level 23 or later
• Outbound HTTPS (port 443) to api.voicepatrol.dev
• Microphone permission, unless your voice provider sends the audio (server-to-server)

Installation Steps

1. Download the VoicePatrol Unity package from your project's Set up tab at dashboard.voicepatrol.dev.
2. Import it: Assets > Import Package > Custom Package..., then select the package.
3. Add the prefab for your voice chat to your start scene: VoicePatrol_Photon for Photon Voice, VoicePatrol_Vivox for Vivox, or VoicePatrol_UnityExample for any other voice chat, or none.
4. Paste your API key into the prefab in the Inspector. The prefab's setup checklist shows what's left to do.
5. Start VoicePatrol after the player logs in (see Quick Integration).

Upgrading to 3.1

1. Import the 3.1 package over your existing VoicePatrol folder. Asset IDs haven't changed, so prefabs and scene references keep working.
2. Replace calls to SetMetadata with SetDisplayName.
3. If you pass useCdn to StartVoicePatrol, remove that argument. A call that passes it by position still compiles, but every later argument shifts by one.
4. Optionally, rename Severity.Medium to Severity.Low and Severity.Severe to Severity.Critical. The old names remain as obsolete aliases.
5. Upgrading from 2.x? Update your violation handler to read findings and a severity instead of labels and a priority (see Moderation Results), and allow HTTPS (port 443) to api.voicepatrol.dev. Port 50051 is no longer used.

Core Concepts

SDK Lifecycle

1. Start: StartVoicePatrol, or the prefab's Initialize, connects in the background.
2. Muted: the SDK starts muted, so nothing is moderated or counted toward usage.
3. Active: unmute while other players can hear the player. The prefabs do this for you from your voice chat's state.
4. Rooms: OnJoinedRoom and OnLeftRoom tell VoicePatrol which room the player is in, shown with each event.
5. Shutdown: the SDK cleans up when the application quits.

Audio Processing Pipeline

Microphone or voice chat → speech detection on the device → speech segments uploaded over HTTPS → moderation → result in your game, on the dashboard and by webhook.

The SDK cuts each player's audio at natural pauses and uploads only speech. Silence and background noise never leave the device. A segment is sent at the first pause after 15 seconds of audio, or at 25 seconds, and its result usually follows within a few seconds.

Unique ID and Display Name

The unique ID is the player's stable ID, the same in every session and on every device. Results, the dashboard and player reports all key on it, so don't use anything that changes, and don't use spaces. The display name is the name other players see. It can change, and the player's profile on the dashboard lists every name they have used.

Key Components

• VoicePatrolWrapper: static methods for every SDK operation, callable from anywhere.
• VoicePatrol prefabs (VoicePatrolBase): Photon, Vivox and Unity integrations that start the SDK, follow your voice chat's state, and can mute offenders automatically.
• AudioCaptureProxy: captures the game's mixed audio output for player reports.
• Permission manager: requests microphone permission on Android, and degrades gracefully when it's denied.

Quick Integration

1. Add the prefab and your API key

Drag the prefab for your voice chat into your start scene, and paste your API key in the Inspector. The prefab persists across scenes.

2. Start VoicePatrol after the player logs in

Pass the player's unique ID and display name:

VoicePatrolBase.Instance?.Initialize(playerId, displayName);

// Later, if the player changes their name
VoicePatrolBase.Instance?.SetDisplayName(newDisplayName);

Without a prefab, start the SDK from the wrapper, and unmute it while other players can hear the player:

VoicePatrolWrapper.SetDisplayName(displayName);
string status = VoicePatrolWrapper.StartVoicePatrol(apiKey, playerId);
Debug.Log($"VoicePatrol: {status}");

VoicePatrolWrapper.SetMuted(false);

3. Act on results

Turn on Enable Automated Muting in the prefab to mute offenders automatically, with progressive mute rules. Only violations at or above its Minimum Severity (High by default) count. Or handle results yourself:

void OnEnable() => VoicePatrolWrapper.OnViolationDetected += HandleViolation;
void OnDisable() => VoicePatrolWrapper.OnViolationDetected -= HandleViolation;

void HandleViolation(VoicePatrolWrapper.ViolationEventData e)
{
    if (e.Severity >= VoicePatrolWrapper.Severity.High)
        MutePlayer(e.UniqueId);

    foreach (VoicePatrolWrapper.Finding finding in e.Findings)
        Debug.Log($"{e.DisplayName} ({e.UniqueId}): {finding.Category}, " +
                  $"{VoicePatrolWrapper.SeverityName(finding.Severity)}, event {e.EventId}");
}

4. Tell VoicePatrol about rooms

The prefabs pass their voice room's name for you. Otherwise:

VoicePatrolWrapper.OnJoinedRoom(roomId); // on joining a voice room or match
VoicePatrolWrapper.OnLeftRoom(); // on leaving it

API Reference

All methods are static on VoicePatrolWrapper.

Voice Engine Integration

Add the prefab for your voice chat. It follows your voice chat's state, moderating the player while they're in a voice room and transmitting, and pausing otherwise.

Moderation Results

Severity

• 1 Low (named Medium before 3.1)
• 2 High
• 3 Critical (named Severe before 3.1)

Make decisions on severity. To display one, use VoicePatrolWrapper.SeverityName(severity), because the obsolete aliases share values.

Categories

Categories are strings, such as hate, threat, sexual, minors, doxxing, self_harm and custom. VoicePatrolWrapper.Categories lists the common ones, but new categories can appear without an SDK update, so use them for display, reports and appeals rather than for decisions.

Webhooks

To receive flagged events on your backend, turn on Event Forwarding in your project's External API tab on the dashboard. Each event includes the player's unique ID, display name, room, categories and severity.

Best Practices

• Use a stable unique ID, such as your account or platform user ID, so each player keeps one history on the dashboard.
• Set the display name whenever it changes, so moderators see who the player appeared as.
• Pause with SetMuted, or SetForceMuted with a prefab, not StopVoicePatrol.
• Pause in menus, single player and private rooms, so players are never moderated when nobody can hear them. The prefabs can skip rooms whose name contains a private-room identifier.
• Unsubscribe from events when your component is destroyed.

void OnDestroy()
{
    VoicePatrolWrapper.OnViolationDetected -= HandleViolation;
    VoicePatrolWrapper.OnAgeVerified -= HandleAgeVerified;
}

void OnApplicationPause(bool paused)
{
    if (paused) VoicePatrolWrapper.SetMuted(true);
}

Troubleshooting

No results

• Check that the SDK is unmuted: it starts muted.
• Check the API key, and that the prefab's setup checklist is complete.
• Check that HTTPS (port 443) to api.voicepatrol.dev is allowed.
• On Android, check that microphone permission was granted.
• Low events don't reach your game by default. Every event, including Low ones, appears on the dashboard within seconds.

Debug logs

Start with debug logs on, or turn on Debug Logs in the prefab, to see initialization, audio devices, uploads, results and authentication errors in the console.

VoicePatrolWrapper.StartVoicePatrol(apiKey, playerId, debugLogs: true);

Audio clip processing fails

Set the clip's Load Type to Decompress On Load in its import settings.

Platform-Specific Notes

Android

• API level 23 or later, arm64-v8a and armeabi-v7a.
• Microphone permission is requested automatically, unless the microphone is disabled.
• Compatible with 16 KB page sizes.

Windows, macOS and Linux

• Windows x64 and x86, macOS 10.15 or later (Intel) and 11 or later (Apple silicon), and Linux x64 with glibc 2.34 or later.
• Each native library is enabled only for its own platform, so 32-bit Windows builds work.

Introduction

VoicePatrol moderates voice chat in multiplayer games in real time. The Unreal plugin moderates what your players say in voice chat, uploads only speech, and returns results to your game within seconds. Every event also appears on your dashboard.

What's new in 3.1

Plugin 3.1 is the first 3.x release for Unreal, and follows straight on from 2.5.6.

• Voice chat integration: moderate the voice your game's voice chat sends (EOS voice, Vivox, or any other) with Attach To Voice Chat or Push Audio, instead of opening the microphone twice.
• Consoles: on PlayStation, Xbox, Switch and other platforms, the plugin builds the SDK from source with your engine's toolchain.
• HTTPS through the engine: every request goes through Unreal's HTTP module, so your project's proxy, certificate and network settings apply.
• Findings and severity: results carry findings, each with a category and severity, instead of labels.
• Display names and rooms are shown with every event on the dashboard, in results and in webhooks.
• Severity names: Low, High and Critical (formerly Medium, High and Severe).
• Speech only: silence and background noise never leave the device.

Real-time Voice Moderation

Automatically detect hate, threats, sexual content, harassment and other harmful speech, and act on it in game.

Multi-platform Support

Windows and Android with prebuilt libraries, and PlayStation, Xbox, Switch, Linux, Mac and iOS from source.

Works With Your Voice Chat

EOS voice, Vivox, the EOS SDK directly, or any voice chat that can hand over its audio.

Installation & Setup

Requirements

• Unreal Engine 5
• Windows x64 or Android arm64-v8a (API level 23 or later) with the prebuilt library, or any other platform with a source build
• Outbound HTTPS (port 443) to api.voicepatrol.dev
• Your project's API key from the dashboard

Installation Steps

1. Download the VoicePatrol Unreal plugin from your project's Set up tab at dashboard.voicepatrol.dev.
2. Close the editor, then extract the zip into your project's Plugins folder, so you have Plugins/VoicePatrolSDK. Create the Plugins folder at the project root if you don't have one.
3. Open the project. Unreal builds the plugin with it.
4. Verify: on Windows and Android, the Output Log shows LogVoicePatrol: VoicePatrolSDK: All required SDK exports resolved.

Upgrading from 2.5.6

1. Close the editor, delete your project's Plugins/VoicePatrolSDK folder, and extract the 3.1 zip into Plugins.
2. Update your StartVoicePatrol call: SessionID and VoiceBI are gone, DeviceID is now UniqueID, and HeadlessMode is now DisableMicrophone. In Blueprints, reconnect the Start Voice Patrol node's new pins.
3. Update your violation handler: results now carry findings and a severity instead of labels (see Moderation Results).
4. In C++, rename EVoicePatrolSeverity::Medium to Low and Severe to Critical. Blueprints update themselves.
5. Optionally, set the player's display name with SetDisplayName, and their room with OnJoinedRoom.
6. If your network allowlists VoicePatrol, allow HTTPS (port 443) to api.voicepatrol.dev. Port 50051 is no longer used.

Core Concepts

How Audio Reaches VoicePatrol

• EOS voice (EOSVoiceChat plugin) or Vivox: call Attach To Voice Chat.
• The Online Subsystem EOS: call AttachToVoiceChatUser from C++.
• The EOS SDK directly, or another voice chat: push its audio with PushAudioPcm16 or Push Audio.
• No voice chat SDK (Windows and Android only): the plugin opens the microphone itself.

On consoles, use your voice chat. The plugin's own microphone capture isn't available there.

Audio Processing Pipeline

Voice chat or microphone → speech detection on the device → speech segments uploaded over HTTPS → moderation → result in your game, on the dashboard and by webhook.

The SDK cuts each player's audio at natural pauses and uploads only speech. A segment is sent at the first pause after 15 seconds of audio, or at 25 seconds, and its result usually follows within a few seconds.

Unique ID and Display Name

The unique ID is the player's stable ID, the same in every session and on every device. Results, the dashboard and player reports all key on it, so don't use anything that changes, and don't use spaces. The display name is the name other players see. It can change, and the player's profile on the dashboard lists every name they have used.

Key Components

• UVoicePatrolSubsystem: a Game Instance subsystem, and the interface for every SDK operation. Get it with GetGameInstance()->GetSubsystem<UVoicePatrolSubsystem>(), or Get Game Instance → Get Subsystem (Voice Patrol Subsystem) in Blueprints. Results are delivered on the game thread.
• FVoicePatrolSDKModule: loads the SDK at startup. IsReady() says whether it loaded.
• UVoicePatrolBlueprintLibrary: Blueprint helpers for testing.

API Reference

All functions are on UVoicePatrolSubsystem, and the Blueprint nodes have the same names.

UVoicePatrolSubsystem* VoicePatrol = GetGameInstance()->GetSubsystem<UVoicePatrolSubsystem>();

Moderation Results

Bind On Violation Detected in Blueprints, or OnInfractionIdentified() in C++. Each result is one FVoicePatrolViolation:

• UniqueId: the player's unique ID.
• EventId: the event's ID on the dashboard and in webhooks.
• DisplayName and RoomId: the player's display name and room when they spoke, empty when unknown.
• Findings: each has a Category (string) and a Severity.
• Severity: the highest severity among the findings. Act on this.

VoicePatrol->OnInfractionIdentified().AddLambda([](const FVoicePatrolViolation& Violation)
{
    if (Violation.Severity >= EVoicePatrolSeverity::High)
    {
        MutePlayer(Violation.UniqueId);
    }
    for (const FVoicePatrolFinding& Finding : Violation.Findings)
    {
        UE_LOG(LogTemp, Log, TEXT("%s: %s, event %s"),
            *Violation.UniqueId, *Finding.Category, *Violation.EventId);
    }
});

Severity

• 1 Low (named Medium before 3.1)
• 2 High
• 3 Critical (named Severe before 3.1)

Your game receives flagged events only: High and Critical by default, which you can change in the dashboard's Moderation settings.

Categories

Categories are strings, such as hate, threat and sexual. VoicePatrolCategories lists the common ones, but new categories can appear without a plugin update, so make decisions on severity, and use the category for display, reports and appeals.

Webhooks

To receive flagged events on your backend, turn on Event Forwarding in your project's External API tab on the dashboard.

Voice Engine Integration

Moderate the voice your game's voice chat sends: what other players actually hear. This avoids capturing the microphone twice, and it's how the plugin works on consoles.

Advanced Features

Consoles and Other Platforms

Windows and Android use the prebuilt library in Libs/. On every other platform, including PlayStation, Xbox and Switch, the plugin compiles the SDK from the source in Source/ThirdParty/VoicePatrolCore with your engine's toolchain, using the engine's own Opus, Ogg and HTTP modules. Those builds have no microphone capture, so start with Disable Microphone and attach your voice chat. If you don't, StartVoicePatrol disables the microphone itself and logs a warning. Console support is new in 3.1, so please let us know how your first console build goes.

Age Verification

With AgeVerification on, VoicePatrol estimates the player's age range from their first 60 seconds of speech. Bind On Age Verified in Blueprints, or OnAgeClassificationReceived() in C++:

VoicePatrol->OnAgeClassificationReceived().AddLambda([](uint32 MinAge, uint32 MaxAge)
{
    if (MaxAge <= 12) EnableChildSafetyMode();
    else if (MaxAge <= 15) EnableTeenSafetyFeatures();
    else EnableFullFeatures();
});

Testing Your Integration

• Turn on Widget Enabled in Start Voice Patrol to see the SDK's status and each result on screen.
• Send a recording through VoicePatrol with the console command VoicePatrol.TestModerationWithRecording <path to a WAV file>, or the Test Moderation With Sound Wave Blueprint node.
• Every event, including Low ones your game doesn't receive, appears on the dashboard within seconds.

Best Practices

• Use a stable unique ID, such as your EOS Product User ID or account ID, so each player keeps one history on the dashboard.
• Set the display name whenever it changes, so moderators see who the player appeared as.
• Prefer your voice chat over the plugin's microphone, so you moderate exactly what other players hear.
• Pause with SetForceMuted or SetMuted, not StopVoicePatrol.
• Unbind delegates when your object ends play.

void AYourGameMode::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    if (UVoicePatrolSubsystem* VoicePatrol = GetGameInstance()->GetSubsystem<UVoicePatrolSubsystem>())
    {
        VoicePatrol->OnInfractionIdentified().RemoveAll(this);
        VoicePatrol->OnAgeClassificationReceived().RemoveAll(this);
    }
    Super::EndPlay(EndPlayReason);
}

Troubleshooting

SDK doesn't start

On Windows and Android, look for All required SDK exports resolved in the Output Log at startup. If it's missing, check that the plugin's Libs/ folder has the library for your platform, and that you extracted the 3.1 zip into a clean Plugins/VoicePatrolSDK folder.

No results

• With voice chat attached, check that the player is in a voice channel and transmitting, and isn't force muted.
• With the plugin's microphone or pushed audio, check that SetMuted(false) was called: the SDK starts muted.
• Check that audio is arriving with GetInputLevel, or the debug widget.
• Check that HTTPS (port 443) to api.voicepatrol.dev is allowed, including your project's HTTP proxy settings.
• Low events don't reach your game by default. Check the dashboard, which shows every event.

Debug logs

VoicePatrol->StartVoicePatrol(ApiKey, PlayerId, false, true, /*LogsEnabled*/ true, /*WidgetEnabled*/ true);

Platform notes

• Android: arm64-v8a, API level 23 or later, compatible with 16 KB page sizes.
• Windows: x64. The library is staged in packaged builds automatically.
• Consoles, Linux, Mac and iOS: source build, with voice chat audio only.
• Dedicated servers: the plugin doesn't run there, and builds for them without the voice chat interface.

Introduction

With server-to-server moderation, your voice provider's servers or your own voice servers send players' audio straight to VoicePatrol. Nothing runs on the game client, so it works on every platform you ship to.

Choose Your Setup

• Photon Voice: add the VoicePatrol plugin to your Photon Voice app.
• Vivox: point Vivox real-time recording at VoicePatrol in Unity Gaming Services.
• Your own voice servers: use the VoicePatrol server kit, a small C library for Linux and Windows.

Getting Results, Choose One or Both

• Webhooks, no game code: turn on Event Forwarding in your project's External API tab, and flagged events are sent to your backend.
• In-game callbacks and muting (Photon and Vivox): add the Unity Photon or Vivox prefab with Headless Mode on, or start the Unreal plugin with Disable Microphone on. No audio is sent from the game.

VoicePatrol doesn't mute players by itself. Use Enable Automated Muting in the Unity prefab, or mute players in your game or backend when a flagged event arrives.

Match the player's ID: audio is matched to players by their unique ID. Use the same stable ID for the player in your voice provider or voice servers as in your game, or callbacks won't match and their history splits on the dashboard.

Photon

1. Create the plugin: in the Photon dashboard, select Manage on your Voice app, then Create VoicePatrol Plugin.
2. Configure it: set ApiKey to your VoicePatrol API key and IsActive to true, then save.
3. Match the player's ID: when the player logs in to Photon, set Client.UserId to the unique ID you use for them in your game. Photon allows this before joining a room.

For results in a Unity game, add the VoicePatrol_Photon prefab with Headless Mode on, and call Initialize with the same ID:

VoicePatrolBase.Instance?.Initialize(playerId, displayName);

Vivox

1. Open Recording: in Unity Gaming Services, open Vivox Recording, then Edit configuration.
2. Point it at VoicePatrol: set Destination URL to the address below, and API key to your VoicePatrol API key.
3. Match the player's ID: when the player logs in to Vivox, set their PlayerId to the unique ID you use for them in your game.

wss://audiom.voicepatrol.dev:6443/ws/vivox

For results in a Unity game, add the VoicePatrol_Vivox prefab with Headless Mode on. In Unreal, start the plugin with Disable Microphone on.

Server Kit

Running your own voice servers? The server kit gives each talking player a handle, and you push their audio into it, as the Opus packets your server already relays or as PCM. It runs the same speech detection and segmenting as the VoicePatrol SDK on game clients: it keeps only speech, cuts each player's audio at natural pauses, and encodes and uploads it, with retries. Results come back to you by webhook.

Download it from your project's Set up tab on the dashboard (Server-to-server → Custom).

Contents

• include/voicepatrol_server.h: the C API, with every call documented.
• lib/linux-x86_64/libVoicePatrol_Server.so: Linux, glibc 2.34 or later.
• lib/windows-x64/VoicePatrol_Server.dll and .lib: Windows, for development.
• example/stream_wav.c: streams WAV files as if each were a player talking.
• The library carries its own HTTPS client and audio codecs, and needs no other libraries.

Integration

#include "voicepatrol_server.h"

vp_server_config config = {0};
config.api_key = "..."; /* your VoicePatrol API key */
config.log = my_log_function; /* optional */
vp_server* vp = vp_server_create(&config);

/* A player starts talking in a room */
vp_player* p = vp_player_open(vp, unique_id, room_id);
vp_player_set_display_name(p, display_name); /* optional */

/* For every voice packet you receive from them */
vp_player_push_opus(p, packet, packet_length);

/* They released push-to-talk, or their client stopped sending */
vp_player_gap(p);

/* They moved rooms, or left */
vp_player_set_room(p, new_room_id);
vp_player_close(p);

/* Shutting down: send what's left, then stop */
vp_server_drain(vp, 30000);
vp_server_destroy(vp);

• Unique ID: your stable ID for the player, the same in every session. If your game client also uses the VoicePatrol SDK, for example for player reports, pass it the same ID.
• Display name: optional, shown with each of the player's events on the dashboard and in webhooks. Call it again if the name changes. Names over 64 characters are cut.
• Audio: vp_player_push_opus takes Opus packets exactly as your clients send them, at any frame size, sample rate or channel count. vp_player_push_pcm takes 16-bit PCM at any rate. 16 kHz mono is cheapest.
• Threads: pushing only runs speech detection, which takes microseconds. Encoding and uploads run on the kit's own threads. Calls for one player must not overlap; different players can be fed from different threads.
• Rooms: optional, shown with each of the player's events.

Trying It

export VOICEPATROL_API_KEY=your-key
./stream_wav --player-prefix test-player- --display-name "Test Player" speech.wav other-speech.wav

Each file becomes a player. Use a file with a violation in it, and its result arrives at your webhook within seconds.

How Audio Is Processed

1. Speech detection: audio is decoded to 16 kHz mono and checked in 20 ms frames. The detector looks at speech frequencies rather than loudness, so fans, music and breathing rarely trigger it.
2. Onset: a segment opens after 60 ms of continuous speech, and keeps the 300 ms before it, so the first word arrives whole.
3. Silence: pauses inside a segment are kept, but shortened to 1 second. Audio between segments is dropped, so a silent player uploads nothing.
4. Cut: once a segment holds at least 15 seconds of audio and 3 seconds of speech, it is cut at the next pause, so sentences stay whole. At 25 seconds it is cut regardless.
5. Encoding: each segment is encoded as Ogg/Opus at 24 kbit/s, about 75 KB for 25 seconds, and uploaded.

Uploads and Errors

• No response, a timeout or a 5xx: the kit retries the same segment after backoff. VoicePatrol never moderates a segment twice.
• 429 (usage limit): audio is dropped for the period the response gives.
• 400 or 413: that segment is dropped.
• 401 or 403: uploads stop and an error is logged. Check the API key and the subscription.

If uploads can't keep up, up to max_backlog_minutes of audio waits (60 by default), and the oldest is dropped beyond that. vp_server_get_stats returns counts of segments cut, uploaded, retried, rejected and dropped, for your metrics.

Webhooks

Open your project's settings on the dashboard, go to the External API tab, and turn on Event Forwarding. Enter your endpoint's URL, and set a webhook secret so you can verify each request. Each project forwards its own results.

Only flagged events are forwarded. The flag thresholds in the Moderation tab decide what's flagged in each category. Each request carries a batch of up to 100 results:

{
  "organization_id": "6f1c...",
  "timestamp": "2026-10-28T03:12:45Z",
  "data": [
    {
      "id": "0d3e...",
      "project_id": "9a2b...",
      "unique_id": "player-123",
      "display_name": "Sparky",
      "room_id": "lobby-7",
      "categories": ["hate"],
      "severity_level": 3,
      "severity_label": "critical",
      "transcription": "...",
      "timestamp": "2026-10-28T03:12:44Z"
    }
  ]
}

• display_name and room_id are the ones the player had when they spoke, and are left out when unknown.
• severity_level is 1 (low), 2 (high) or 3 (critical). Act on the number: the labels may change.
• Webhooks set up before SDK 3.1 keep the legacy format until you switch them in the dashboard: the same fields, plus device_id and severity (medium, high or severe).

Verify Every Request

X-VoicePatrol-Signature is sha256= followed by the hex HMAC-SHA256, keyed with your webhook secret, of X-VoicePatrol-Timestamp + "." + the raw request body. Reject requests whose timestamp is more than 5 minutes from your clock, and compare signatures in constant time:

import hashlib, hmac, time

def verify(secret: bytes, timestamp: str, body: bytes, signature: str) -> bool:
    if abs(time.time() - int(timestamp)) > 300:
        return False
    expected = "sha256=" + hmac.new(secret, timestamp.encode() + b"." + body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)

Sizing

Encoding is most of the cost. One core of an Intel i9-13900K handles about 220 players talking continuously, including decoding their Opus packets. A typical cloud vCPU is roughly half as fast. Silence isn't encoded, so players who talk part of the time cost proportionally less.

• One encoder thread is the default. Raise encoder_threads if vp_server_get_stats shows the queue growing while uploads are healthy.
• Upload bandwidth is about 3 KB/s per talking player.
• Need to build from source, port the kit to another platform, or call the HTTP API directly? Contact us.