Unreal In-Game Chat Tutorial

Set up your development environment

In this tutorial, we will use the Stream Chat API and the Unreal SDK to add in-game chat to a new Unreal Engine template project.

Before you start, make sure you have:

• Unreal Engine 5.7 or 5.8, installed from the Epic Games launcher. Leave "Templates and Feature Packs" ticked in the install options (it is by default) so the Third Person template is available.
• A C++ toolchain. The plugin ships as source rather than prebuilt binaries, so Unreal compiles it the first time you open the project. That means Xcode on macOS, Visual Studio with the "Game development with C++" workload on Windows, or clang on Linux. On macOS, each engine version accepts only a range of Xcode versions - if a build fails with Platform Mac is not a valid platform to build, your Xcode is outside the range that engine allows.

Stream Chat for Unreal 2.0.0 supports Unreal Engine 5.7 and 5.8. v1.3.0 covers UE 4.27, 5.0 and 5.1, and no release supports 5.2 through 5.6. The steps below are written for 5.7 and 5.8; they mostly hold on older versions, but some editor menus sit in different places.

Working with an AI agent

This tutorial is Blueprint-driven: the chat logic is a node graph you paste into the editor, which is a human step no agent can do for you. So unlike our other chat tutorials, follow the steps below yourself - the graph is the fastest way to see in-game chat working.

Where an agent does earn its keep is the C++ integration you will most likely ship: resolving the right plugin archive for your engine version, the Build.cs module dependencies, the client lifetime on your HUD, the UMG widget wiring, and the per-platform packaging config. Install the CLI and the skills, and it works from the current SDK source and docs instead of stale training data:

1
2
3
4
5
6
7
8
# Install the getstream CLI
curl -fsSL https://getstream.io/cli.sh | bash

# Install the skills (router, docs, and builder). Pick the target: --universal for
# Cursor, Codex, and other AGENTS-ecosystem tools, or --claude for Claude Code.
# The Unreal pack installs on demand the first time it's needed, or add it explicitly:
getstream skills --universal
getstream skills stream-unreal --universal

Then ask your agent:

1
2
3
4
/stream-unreal Add Stream Chat to my Unreal project in C++: install the plugin for my
engine version, put the client on my HUD, connect a user, watch a channel, and show the
in-game chat widget. Provision credentials with the CLI (create/select my org and app,
mint a token), or fall back to the tutorial demo credentials if I'm not logged in.

The agent hands back to you at two points: browser sign-in during getstream init, and running the project in the editor.

The /stream-unreal skill knows the traps that cost the most time here - that ApiKey has to be set before BeginPlay or every REST call 401s while the websocket still connects, that the shipped widgets are Blueprint assets rather than instantiable C++ classes, and the packaging config a mobile build needs. It also refuses to write against features the SDK does not have yet, rather than emitting an API that does not exist.

Create a new Unreal project

In the Unreal Project Browser, select the Games category and choose the Third Person template.

Keep all the default settings and name the project: ChatExample.

Download and enable the Unreal Chat plugin

The Unreal Chat SDK includes the core functionality you need to interact with the Stream Chat API, with support for messages, channels, reactions and more. The SDK also incorporates a selection of Widgets to get you started building your own chat user experience in Unreal.

Go to the Releases page of the GitHub repository. There is one archive per engine version - StreamChat-5.7.zip and StreamChat-5.8.zip - so take the one matching the engine you created the project with. Picking the wrong one is a mismatch you find out about at compile time rather than a clean error.

Extract it into a Plugins directory at the root of your project, creating that directory if it isn't there yet. The archive already contains a top-level StreamChat folder, so you should end up with:

1
2
3
4
5
6
7
8
ChatExample/
  ChatExample.uproject
  Plugins/
    StreamChat/
      StreamChat.uplugin
      Source/
      Content/
      Resources/

GitHub Releases is the supported way to get the plugin. It used to be listed on the Unreal Engine Marketplace, which Epic replaced with Fab in October 2024; if you acquired it there, it stays available in your Vault.

The archive contains source, not binaries, so the next time you open ChatExample.uproject Unreal offers to rebuild the missing modules. Accept, and let it compile.

Once the editor is up, check that the Stream Chat plugin is enabled under Edit > Plugins.

Create a HUD Blueprint

Now we need to create our first Blueprint which will host the Stream Chat Client component. Generally, you'll want to attach the component to an Actor which is client-side only, as our implementation doesn't utilize the Unreal client-server architecture for network communication. A good choice is the HUD Actor, which will only ever spawn on the client and is conventionally used for cosmetic functionality such as user interfaces.

Create a new Blueprint based on the HUD Actor. An easy way to do this is to open the BP_ThirdPersonGameMode Blueprint (in Content/ThirdPerson/Blueprints), press the plus button next to "HUD Class", and select a name and location for the new Blueprint. Let's call it BP_ExampleChatHUD.

If you've already created a HUD Blueprint elsewhere, ensure you have it selected in the BP_ThirdPersonGameMode Blueprint.

Next, add the Stream Chat Client component to the Actor, and set the API Key property of the new component to: kmajgxb2rk4p.

When you create your own project, you should use the API key obtained from your project dashboard.

Select and delete all Blueprint nodes in the HUD actor, then copy and paste the following Blueprint nodes in their place.

You can click "Fullscreen" or zoom out, then drag around all the nodes and press Ctrl/Cmd+C to copy these nodes to your clipboard for pasting directly into Unreal.

Let's have a look at what these nodes do:

• We connect to the Stream Chat API via the Connect User latent node. We'll be testing our game locally with two players, so using Is Server is an easy way to choose between two different users for the two sessions. We pass in a user token for each user.
• We start watching a messaging channel with our two users as members, built with Make Channel Properties (User Ids) and returned by Watch Channel.
• We create a new WBP_InGameChat widget, call Setup on it with the channel we just received, and add it to the viewport.

In this tutorial, the user tokens are hardcoded and are only valid for the given API key. In a production scenario, user tokens should be generated using your own custom backend and our server SDK.

Input bindings

The last step before we can test things out is to set up an input binding to open the in-game chat menu. Go to Project Settings... from the Edit menu, select the Input category under Engine, and expand Bindings. Add a new Action Mapping named Chat and choose an appropriate key. Here we've chosen Slash.

The name has to be exactly Chat. It is the default of the widget's Open Chat Input Action Name property, which the widget passes to ListenForInputAction - so a mapping called anything else leaves the key doing nothing, with no error to tell you why. The property sits on the nested fading message list widget rather than on WBP_InGameChat itself, and it belongs to the plugin's own content, so changing it means duplicating the widget into your project first or losing the edit on the next plugin update. Sticking with Chat is the simpler path.

Unreal shows a notice here that Action and Axis Mappings are deprecated in favor of Enhanced Input. That's expected: the chat widget opens itself with ListenForInputAction, which reads these mappings, and both are still present and working in UE 5.7 and 5.8.

Test!

Now we're ready to test the in-game chat! Open the dropdown next to the Play button in the level editor toolbar. Under Multiplayer Options, set Number of Players to 2 and Net Mode to Play As Listen Server.

Then, under Modes in the same dropdown, choose New Editor Window (PIE) to launch two instances of the game. Press / to open the in-game chat menu, type a short message and press Enter. Your message will appear for you and the other user!

Because the Blueprint picks its user with Is Server, the listen-server window signs in as one of the two hardcoded users (niko and tommy) and the client window signs in as the other, which is what lets you see both sides of the conversation.

Before you build on this

The graph above is deliberately the shortest path to a working chat window. Three things to add before it becomes part of a real project:

• Disconnect on teardown. The graph connects in BeginPlay and never disconnects. Add an Event EndPlay to the HUD with a Disconnect User call, otherwise the websocket is only torn down at garbage collection, and in the editor the previous PIE session's connection outlives the session and the user stays online.

• Set the API key before BeginPlay runs. Setting it on the component in the Details panel, as you did above, is correct because the value is in place before play starts. If you later move the key somewhere that assigns it during BeginPlay, you get a client that looks like it works - Connect User succeeds and the websocket connects - while every other call fails with 401 and api_key or app_id not provided. The empty api_key= in the failing URL is the giveaway.

• Add n.VerifyPeer=True before you package. The editor works without it, but a packaged build cannot verify Stream's TLS certificate and never connects, logging SSL error: unable to get local issuer certificate and retrying forever. Add this to Config/DefaultEngine.ini:

  ini

  1
  2
  [/Script/Engine.NetworkSettings]
  n.VerifyPeer=True

  It is what makes the engine's CA certificates get staged into the packaged build. Setting it does not make the app less strict; an unset key already meant "verify the peer" at runtime.

Run the finished sample

The SDK repository is itself a playable Unreal project, and the map behind this tutorial ships with it alongside three larger demos. If you get stuck, it's the quickest way to compare against something known to work.

The assets are stored in Git LFS, so fetch them before opening the project - without LFS you get pointer files instead of real assets and the maps fail to load. The just recipes wrap the engine invocations and locate your engine automatically:

1
2
3
4
5
6
7
git clone https://github.com/GetStream/stream-chat-unreal.git
cd stream-chat-unreal
git lfs install && git lfs pull

just build-editor    # compile the C++ once
just run tutorial    # the map used by this tutorial
just demo            # the flagship team chat demo

Congratulations

We hope that you've enjoyed this tutorial. By using Stream's Chat Components, you and your team will be able to get your Unreal Game or Application up and running with chat in minutes.

Now that you've completed the tutorial on Stream Chat, you can build anything chat related with our components. If you have a use-case that doesn't quite seem to work, or simply have questions, get in touch with us.

What you get today

Everything you just wired up runs on the same API as the rest of our SDKs, and a good deal more is already available from Blueprint and C++: channel querying and watching, message editing and search, reactions, read state and unread counts, typing indicators, slow mode, moderation (bans, mutes, flagging), push notification device registration, presence and watchers, and typed real-time events.

The Unreal SDK is still in beta, so it is worth knowing what it does not cover yet before you plan around it. Attachments and file uploads, threaded replies, quoted messages, mentions, pinning, polls, and offline persistence are all on the Stream Chat API but not yet surfaced in Unreal. The repository README tracks the current list, and the C++ reference documents the lower-level API where Blueprint coverage stops short.

Final Thoughts

In this chat tutorial we added basic in-game chat functionality to a game with our Unreal low-level SDK and widget library. From here, the chat SDK for Unreal gives you the building blocks for a full team chat experience, or you can drop the low-level client into whatever UI your game already has.

Machine-readable resources

For AI agents and coding assistants working with this SDK:

• CLI + skills: curl -fsSL https://getstream.io/cli.sh | bash, then getstream skills --universal and getstream skills stream-unreal --universal for the Unreal pack (use --claude for Claude Code). Alternative: npx skills add GetStream/agent-skills -s stream.
• Provisioning: getstream init (auth + create/select org & app) then getstream token <user_id> (mint a token). There is no getstream env target for Unreal - put the API key in Config/DefaultEngine.ini under [/Script/StreamChat.StreamChatClientComponent] or on the component itself.
• Data & config from the CLI: getstream api <Endpoint> --request '{...}' for users, channels, and messages
• Unreal integration skill: invoke /stream-unreal in your agent for plugin install, C++ client wiring, the UMG widget layer, and packaging; /stream-docs searches live SDK docs with citations
• Docs index for LLMs: https://getstream.io/chat/docs/unreal/llms.txt
• Markdown endpoints: append .md to any docs URL for a clean, token-efficient version
• C++ API reference: Doxygen reference for the full class surface
• Source of truth for APIs: the SDK repository - read the pinned version's headers under Plugins/StreamChat/Source/ rather than assuming APIs from training data. Not every page in the Unreal docs carries an Unreal code tab, so a JavaScript sample on a /chat/docs/unreal/ page is not a translatable API.