EOS voice chat

Last updated on September 15, 2026

Voice chat lets players communicate in real-time during gameplay. This guide shows you how to integrate Epic Online Services (EOS) Voice with AccelByte Gaming Services (AGS) to enable voice chat in parties, teams, and game sessions.

What you'll learn

• How to set up EOS Voice Chat with AGS
• How to add voice chat to parties, teams, and game sessions
• How to control voice features in your game

note

The AGS CLI is the unified command-line tool for AGS, and it now includes Extend and AMS tooling. The instructions on this page remain valid today. See the AGS CLI documentation to learn about the unified tool.

How it works

The integration uses two components that work together:

1. Backend Service - An Extend Service Extension app that generates EOS voice tokens
2. Unreal Plugin - Connects players to voice channels using those tokens

When a player joins a party or game session, the game client requests a voice token from the backend service. The backend validates that the player is actually in that party or session, then requests a token from Epic. The player uses that token to join the voice channel.

Voice channel types

The integration supports three types of voice channels:

Channel	Description	Use case
Party	Talk with party members	Friends chatting before and during matches
Team	Talk with teammates in a session	Tactical team communication
Session	Talk with everyone in the match	Lobby chat, casual games

All channels use non-positional (2D) audio, meaning players hear each other at equal volume regardless of in-game position.

Prerequisites

Before you start, make sure you have:

• An AccelByte Gaming Services account with a game namespace
• An Epic Games Developer Portal account with a product configured
• An Unreal Engine project with the AGS SDK installed
• Docker installed for building and deploying the backend service

Get started

Step 1: Set up Epic Developer Portal

First, configure Epic Online Services to work with AccelByte authentication.

1. Open your product in the Epic Developer Portal.

2. Navigate to Product Settings > Clients and create an OAuth client with:

   • Policy Type: TrustedServer
   • Permissions: Voice and Connect enabled

   Keep the Client ID and Client Secret.

3. Note your Deployment ID from the product settings.

4. Navigate to Product Settings > Identity Providers and add an OpenID provider:

   Field	Value
   Identity Provider	OpenID
   Description	AccelByte
   Type	UserInfo Endpoint
   UserInfo API Endpoint	https://{your-ags-domain}/iam/v3/public/users/me
   HTTP Method	GET
   AccountId	userId
   DisplayName	displayName

note

This configuration links AccelByte accounts to Epic, allowing the backend service to generate voice tokens for your players.

Step 2: Deploy the backend service

The backend service handles voice token generation and validates player membership in parties and sessions.

1. Clone the repository:

   git clone https://github.com/AccelByte/extend-eos-voice-rtc.git

2. In the AGS Admin Portal, go to your namespace and navigate to Extend > Service Extension.

3. Click Create New and provide a name for your app (e.g., eos-voice).

4. On the app details page, configure the following environment secrets:

   Secret	Description
   AB_CLIENT_ID	AccelByte OAuth client ID for the service
   AB_CLIENT_SECRET	AccelByte OAuth client secret
   EPIC_CLIENT_ID	Epic Games OAuth client ID
   EPIC_CLIENT_SECRET	Epic Games OAuth client secret
   EPIC_DEPLOYMENT_ID	Epic RTC deployment ID

5. Configure the following environment variables:

   Variable	Value
   BASE_PATH	/eos-voice
   EPIC_BASE_URL	https://api.epicgames.dev
   PLUGIN_GRPC_SERVER_AUTH_ENABLED	true

6. Build and upload the container image using extend-helper-cli:

   export AB_BASE_URL='https://your-ags-domain'
   export AB_CLIENT_ID='your-client-id'
   export AB_CLIENT_SECRET='your-client-secret'
   
   extend-helper-cli image-upload --login --namespace <namespace> --app <app-name> --image-tag v0.0.1

7. On the app details page, click Deploy Latest Image and wait until the status shows RUNNING.

Required permissions for the backend service OAuth client

For AGS Private Cloud:

• ADMIN:ROLE [READ]
• ADMIN:NAMESPACE:{namespace}:NAMESPACE [READ]
• ADMIN:NAMESPACE:{namespace}:SESSION [READ]
• ADMIN:NAMESPACE:{namespace}:SESSION:PARTY [READ]
• ADMIN:NAMESPACE:{namespace}:NOTIFICATION [CREATE]

For AGS Public Cloud:

• IAM > Roles (Read)
• Basic > Namespace (Read)
• Session > Game Session (Read)
• Session > Admin Party (Read)
• Lobby > Notification (Create)

Step 3: Install the Unreal plugin

The Unreal plugin manages voice channel connections and provides a simple API for controlling voice features.

1. Download the AccelByteEOSVoice plugin from the GitHub releases.

2. Copy the plugin to your project's Plugins/ directory.

3. Generate the SDK for the backend service using the Extend Codegen CLI. This creates the AccelByteUe4SdkCustomization plugin that the voice plugin depends on.

4. Enable the required plugins in your .uproject file:

   {
     "Plugins": [
       { "Name": "AccelByteUe4Sdk", "Enabled": true },
       { "Name": "OnlineSubsystemAccelByte", "Enabled": true },
       { "Name": "OnlineSubsystemEOS", "Enabled": true },
       { "Name": "EOSVoiceChat", "Enabled": true },
       { "Name": "AccelByteEOSVoice", "Enabled": true },
       { "Name": "AccelByteUe4SdkCustomization", "Enabled": true }
     ]
   }

Step 4: Configure your project

Add the following configuration to your project's DefaultEngine.ini:

[/Script/AccelByteEOSVoice.AccelByteEOSVoiceConfig]
; Auto-join party voice when creating/joining a party
bAutoJoinPartyVoice=true

; Auto-join team voice when joining a game session
bAutoJoinTeamVoice=false

; Auto-join session-wide voice when joining a game session
bAutoJoinSessionVoice=false

; Auto-generate display names for users without one (format: Player-XXXX)
bAutoGenerateDisplayNameIfEmpty=true

Configure EOS to use OpenID authentication:

[/Script/OnlineSubsystemEOS.EOSSettings]
bUseEAS=false
bUseEOSConnect=true
bUseNewLoginFlow=true

Step 5: Test voice chat

1. Launch your game with two players.

2. Have both players log in and join the same party.

3. Verify that voice communication works between the players.

If voice chat doesn't connect, check the Troubleshooting section.

Control voice features

The plugin provides a simple C++ API for controlling voice features at runtime.

Get the voice subsystem

// Get the voice subsystem from the game instance
UGameInstance* GameInstance = GetWorld()->GetGameInstance();
UAccelByteEOSVoiceSubsystem* VoiceSubsystem =
    GameInstance->GetSubsystem<UAccelByteEOSVoiceSubsystem>();

Mute your microphone

// Mute your microphone
VoiceSubsystem->SetAudioInputDeviceMuted(true);

// Unmute your microphone
VoiceSubsystem->SetAudioInputDeviceMuted(false);

Mute your speakers

// Mute all incoming voice (deafen)
VoiceSubsystem->SetAudioOutputDeviceMuted(true);

// Unmute speakers
VoiceSubsystem->SetAudioOutputDeviceMuted(false);

Mute a specific player

// Mute a specific player by their display name
VoiceSubsystem->SetPlayerMuted(TEXT("PlayerName"), true);

// Unmute the player
VoiceSubsystem->SetPlayerMuted(TEXT("PlayerName"), false);

Switch which channel you transmit to

When a player is in multiple voice channels (e.g., party and team), you can control which channel they transmit to:

// Transmit to party channel only
VoiceSubsystem->TransmitToSpecificChannel(
    EAccelByteEOSVoiceVoiceChannelType::PARTY);

// Transmit to team channel only
VoiceSubsystem->TransmitToSpecificChannel(
    EAccelByteEOSVoiceVoiceChannelType::TEAM);

// Transmit to session channel (all players)
VoiceSubsystem->TransmitToSpecificChannel(
    EAccelByteEOSVoiceVoiceChannelType::SESSION);

Access advanced EOS voice features

For advanced functionality, you can access the underlying EOS voice interface:

IVoiceChatUser* VoiceChatUser = VoiceSubsystem->GetVoiceChatUser();

if (VoiceChatUser)
{
    // Get list of players in a channel
    TArray<FString> Players = VoiceChatUser->GetPlayersInChannel(TEXT("PARTY"));

    // Get all joined channels
    TArray<FString> Channels = VoiceChatUser->GetChannels();

    // Check if currently transmitting
    bool bIsTransmitting = VoiceChatUser->IsTransmitting();
}

Troubleshooting

Voice chat not connecting

Check these common issues

• Verify the backend service is deployed and showing RUNNING status
• Check that EOS Connect is configured in Epic Developer Portal
• Ensure players have joined a party or session before requesting voice
• Confirm bAutoJoinPartyVoice is enabled in your config

Can't hear other players

• Make sure your speakers are not muted in the game
• Verify the other player is in the same voice channel
• Check that both players successfully joined the channel (no errors in logs)
• Ensure bAutoJoinPartyVoice or bAutoJoinSessionVoice is enabled

EOS login fails

Symptoms: Failed to login to EOS voice for LocalUserNum X

Solutions:

• Verify EOS Connect OpenID provider is configured in Epic Developer Portal
• Check that users have a display name (enable bAutoGenerateDisplayNameIfEmpty=true)
• Confirm EOS credentials in DefaultEngine.ini
• Ensure bUseEOSConnect=true and bUseNewLoginFlow=true

Epic account not linked (Error 40303)

Symptoms: Backend returns error code 40303

Solutions:

• Configure EOS Connect OpenID provider in Epic Developer Portal (see Step 1)
• Implement account linking in your game using EOS Connect SDK
• For dev/stage environments: add test accounts to an Epic Player Group with the OpenID identity provider

Permission denied on admin endpoints

Admin endpoints (/admin/session/{session_id}/token and /admin/room/{room_id}/token/revoke) require additional permissions.

important

Admin endpoints are only available in AGS Private Cloud. Custom permissions cannot be created in Public Cloud.

For Private Cloud, add these permissions to your OAuth client:

• ADMIN:NAMESPACE:{namespace}:VOICE [CREATE]
• ADMIN:NAMESPACE:{namespace}:VOICE [DELETE]

Next steps

• Customize the backend service to add custom logic
• Learn about Extend Service Extension architecture
• View the backend service repository for API documentation
• View the Unreal plugin repository for detailed plugin documentation