Epic Online Services Setup: Free Backend in 13 Steps [2026]

Every indie studio hits the same wall eventually: your game works great on one platform, but the moment you want players on Steam, the Epic Games Store, PlayStation, Xbox, and Switch to see each other’s friends lists, join the same lobby, or compare leaderboard scores, you need a backend. Building that backend from scratch means standing up authentication, matchmaking, cloud saves, and anti-cheat as separate services, then gluing them together and hoping nothing breaks under load. Epic Online Services (EOS) exists specifically to remove that build-it-yourself tax, and it does it at zero cost, which is why “epic online services” now pulls roughly 1,900 monthly searches in the US with low keyword competition, according to DataForSEO search volume data pulled in September 2026.

This tutorial walks through registering your game in the Epic Games Developer Portal, generating the credentials your client needs, initializing the EOS platform in code, and wiring up the services most teams reach for first: Connect authentication, Lobbies, Sessions and matchmaking, achievements and leaderboards, Player Data Storage, and Easy Anti-Cheat (EAC). By the end you will have a minimal working cross-platform demo you can extend, plus a troubleshooting reference for the errors you are most likely to hit along the way.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What Epic Online Services Actually Is

Epic Online Services is Epic Games’ free, engine-agnostic backend suite that bundles the online infrastructure most multiplayer games need into a single SDK. Epic’s own product page describes the pitch directly: “Build on any engine, launch on any combination of stores and platforms, and scale up to support more players as success grows—all for free.” That last part is the detail worth sitting with, because the services on offer would otherwise cost real money elsewhere: authentication and account linking through Connect, social features through Epic Account Services, matchmaking through Sessions and Lobbies, voice chat through built-in RTC, achievements, leaderboards, and stats, cloud-synced Player Data Storage and Title Storage, commerce and entitlements, and Easy Anti-Cheat integration for keeping cheaters out.

EOS ships as a native C/C++ SDK with official integrations for Unreal Engine and plugin support for Unity, plus community wrappers for engines like Godot. It targets Windows (including Windows on Arm, added via SDK 1.17.1.3 in August 2025), macOS, Linux through the native SDK, Android, and iOS directly, with console SDKs for PlayStation, Xbox, and Nintendo Switch available through their respective developer portals after you request access. Because EOS does not require players to own an Epic Games Store copy of your game or even have the Epic Games Launcher installed, it works underneath a Steam release, a console exclusive, or a mobile title just as easily as it works underneath a game sold on the Epic Games Store itself.

The production track record backs up the pitch. Epic uses EOS as the connective tissue behind Fortnite’s cross-platform play, and Rocket League and Fall Guys both run their cross-progression and cross-play systems on the same stack after Epic folded them into its ecosystem. When Epic rolled out Windows-on-Arm support for Snapdragon-powered PCs, Fortnite was the title used to battle-test the updated Easy Anti-Cheat client before other EAC-protected games received the same capability.

EOS SDK Version History Worth Knowing

Epic ships EOS SDK updates on a rolling basis rather than a fixed quarterly schedule, and several recent releases changed what a fresh integration should expect out of the box. The table below covers the milestones most relevant to a September 2026 integration; always confirm the exact current build against the official release notes before locking a version into a shipping build.

SDK Build	Approximate Timing	What It Changed
1.17.1.3	August 2025	Added an Arm-native Easy Anti-Cheat client and bootstrapper, enabling EAC-protected titles on Windows-on-Arm (Snapdragon) PCs, battle-tested first with Fortnite
1.18	September 2025	Added Localized Presence (translated status text) and Epic Account Services Friends Web APIs, plus an updated redistributable installer
1.19.x	Late 2025 into 2026	Continued desktop and Android SDK updates referenced by third-party integration kits and Windows-on-Snapdragon documentation

Because point releases land frequently and Epic does not always keep every historical build easily comparable across its own documentation, treat any version number in a tutorial — including the ones above — as a snapshot rather than a guarantee of what you will see when you actually open the SDK download page.

Epic Online Services vs PlayFab vs GameLift vs Steamworks

Before committing engineering time to any backend, it helps to see where EOS sits relative to the alternatives teams usually shortlist. If you have already read our PlayFab Multiplayer Servers setup guide or looked at deploying a multiplayer game server with AWS GameLift, the table below shows how EOS compares on the dimensions that actually change an architecture decision: cost, engine support, and whether anti-cheat is bundled in or something you have to source separately.

Aspect	Epic Online Services	PlayFab	AWS GameLift	Steamworks
Cost	Free for developers and publishers of any size	Usage-based pricing tied to MAU and storage	Usage-based pricing for server fleets and data transfer	Free APIs, but tied to a Steam release
Engine support	Any engine via native C/C++ SDK; official Unreal integration, Unity plugin	Any engine, SDKs for multiple languages	Any engine; focused on server hosting, not client SDKs	Any engine, but the client must run through Steam
Platform neutrality	Store- and platform-agnostic across PC, console, and mobile	Store-agnostic	Store-agnostic, server-side focus	Tied to the Steam ecosystem
Anti-cheat	Bundled Easy Anti-Cheat (EAC), including Windows-on-Arm support	No built-in anti-cheat; usually paired with a third party	No built-in anti-cheat	Valve Anti-Cheat (VAC) for Steam titles
Feature scope	Auth, friends, lobbies, sessions, matchmaking, voice, achievements, leaderboards, stats, cloud saves, entitlements, anti-cheat	Auth, player data, analytics, economy, matchmaking	Dedicated server hosting, fleet scaling, FlexMatch matchmaking	Auth via Steam, matchmaking, stats, achievements, inventory, Workshop

The practical takeaway: EOS is the strongest option when you need cross-platform identity, social features, and anti-cheat without a metered bill, but it does not manage dedicated game server fleets the way GameLift does. Plenty of studios pair the two — EOS for identity, matchmaking, and social layers, GameLift or a Kubernetes-based setup like Agones on Kubernetes for the actual authoritative server processes.

Prerequisites: What You Need Before You Start

Confirm you have the following before starting. Because Epic ships SDK updates frequently, always cross-check the exact current build against Epic’s own EOS release notes page rather than trusting a version number frozen in any single tutorial, including this one.

• A free Epic Games developer account, created at the Epic Games Developer Portal
• The Epic Online Services SDK — Epic’s SDK line moved through the 1.17.x to 1.19.x range across 2025 and into 2026, with SDK 1.17.1.3 (August 2025) adding Windows-on-Arm Easy Anti-Cheat support and SDK 1.18 (September 2025) adding Localized Presence and Epic Account Services Friends Web APIs; always pull the current build from the official SDK download page
• A C/C++ toolchain if you are integrating the native SDK directly: Visual Studio on Windows, Xcode on macOS, or Clang/GCC on Linux
• Unreal Engine 5.x if you are using Epic’s first-party Unreal integration, or a recent Unity version if you are using the Unity plugin path
• Administrative access to create a “product” and configure sandboxes in the Epic Games Developer Portal
• A code editor and a local build target you can run repeatedly during testing (a desktop build is the fastest loop for this tutorial)
• If you plan to test Easy Anti-Cheat, a Windows test machine, since EAC’s primary integration path targets Windows clients first
• Optional: console developer portal access for PlayStation, Xbox, or Nintendo Switch if you intend to ship EOS on those platforms, since console SDKs are gated behind platform-specific approval rather than a public download

None of this requires a paid Epic Games Store publishing agreement. EOS is available to any registered developer regardless of where you plan to distribute your finished game.

Step 1: Create Your Epic Games Developer Account

Head to the Epic Games Developer Portal and sign up with an Epic account, or convert an existing one into a developer account. Epic requires you to accept the Epic Online Services terms of service before you can create a product, and you will need to verify your email address before the portal unlocks the product-creation flow. This step is free and does not commit you to publishing on the Epic Games Store.

If you are working as part of a studio rather than solo, invite teammates to the organization inside the portal now rather than later. Credentials generated under a personal account are painful to migrate to an organization account after you have already shipped a build referencing them.

Step 2: Register a Product in the Developer Portal

Inside the portal, create a new “product.” A product represents your game at the organizational level — it is the container that holds your sandboxes, deployments, and every credential you will generate in later steps. Give it a clear, permanent name, since renaming a product after client code and store listings reference its identifiers adds friction you do not need.

Once the product exists, the portal exposes a Product ID. Note it down alongside the product name — you will paste it into your platform initialization code in Step 6.

Step 3: Configure Sandboxes and Deployments

Every EOS product needs at least one sandbox and one deployment inside that sandbox. Think of a sandbox as an environment — Epic’s default setup gives you something like a development sandbox and a live sandbox — and a deployment as the specific configuration your client connects to within that environment. Most teams run at least two sandboxes: one for active development where you can break things freely, and one for the build you actually ship.

• Create a sandbox named something like dev for local testing
• Create a second sandbox named live for your shipping build
• Inside each sandbox, create a deployment — this is what generates the Deployment ID your client references at runtime
• Keep the mapping between sandbox, deployment, and build channel documented somewhere your whole team can see, since a client pointed at the wrong deployment will authenticate against empty data and look broken for no obvious reason

This separation matters more than it looks like at first glance. If you skip it and develop directly against your live deployment, test data, test achievements, and test leaderboard entries end up mixed in with real player data, and cleaning that up after launch is far more painful than setting up two sandboxes up front.

Step 4: Generate Client Credentials

Inside your product’s Clients section, generate a Client ID and Client Secret. These, together with the Deployment ID from Step 3, are the three values your EOS platform initialization code needs. Epic supports multiple client policy types depending on whether your client is a game client, a dedicated server, or a backend service calling EOS Web APIs, so pick the policy type that matches how this particular credential set will be used.

Treat the Client Secret the way you would treat any other API secret: never commit it to a public repository, and if you are shipping a client-side game binary, be aware that a sufficiently determined player can extract strings from your executable. For most game-client scenarios this is an accepted tradeoff Epic’s own SDK design assumes, but if you are calling EOS Web APIs from a backend service you control, keep that secret server-side only.

Step 5: Download and Install the EOS SDK

From the EOS Get Started documentation, download the SDK package matching your target platform: PC (Windows or macOS), Android, or iOS are available directly; console SDKs require requesting access through the Developer Portal first, after which they appear alongside the public downloads. The SDK package includes headers, static and dynamic libraries, sample projects, and the Easy Anti-Cheat client files if you plan to integrate EAC later in this tutorial.

Extract the SDK into your project’s third-party dependencies folder and add the include path and library path to your build configuration. If you are working in Unreal Engine, Epic’s own EOS plugin wraps most of this for you and exposes Blueprint nodes for common operations; if you are working in Unity or a custom engine, you will call the native C API directly or through a thin C# wrapper.

Step 6: Initialize the EOS Platform in Your Game

Every EOS integration starts with two calls: initializing the SDK once at process startup, then creating a platform instance using the Product ID, Client ID, Client Secret, and Deployment ID you collected in Steps 2 through 4. The snippet below is simplified for readability — treat it as illustrative of the call sequence rather than drop-in production code.

EOS_InitializeOptions InitOptions = {};
InitOptions.ApiVersion = EOS_INITIALIZE_API_LATEST;
InitOptions.ProductName = "MyGame";
InitOptions.ProductVersion = "1.0.0";

EOS_EResult InitResult = EOS_Initialize(&InitOptions);
if (InitResult != EOS_EResult::EOS_Success) {
    // Handle initialization failure before doing anything else
    return;
}

EOS_Platform_Options PlatformOptions = {};
PlatformOptions.ApiVersion = EOS_PLATFORM_OPTIONS_API_LATEST;
PlatformOptions.ProductId = "YOUR_PRODUCT_ID";
PlatformOptions.SandboxId = "YOUR_SANDBOX_ID";
PlatformOptions.DeploymentId = "YOUR_DEPLOYMENT_ID";
PlatformOptions.ClientCredentials.ClientId = "YOUR_CLIENT_ID";
PlatformOptions.ClientCredentials.ClientSecret = "YOUR_CLIENT_SECRET";
PlatformOptions.Flags = EOS_PF_WINDOWS_ENABLE_OVERLAY_D3D9;

EOS_HPlatform PlatformHandle = EOS_Platform_Create(&PlatformOptions);
if (PlatformHandle == nullptr) {
    // Platform creation failed - check credentials and deployment status
    return;
}

Your game loop needs to call EOS_Platform_Tick(PlatformHandle) on a regular cadence — every frame is the common approach — because EOS processes callbacks and network events cooperatively rather than spinning up background threads for you. Forgetting this tick call is one of the most common reasons a freshly wired-up EOS integration appears to “hang” with no error message at all.

Step 7: Implement Connect and Epic Account Login

With the platform handle created, the next step is authenticating a player through the Connect interface. Connect is what lets EOS treat a PlayStation Network account, an Xbox Live account, a Steam account, or a device-local anonymous ID as a single Epic Product User ID (PUID) behind the scenes, which is the mechanism cross-platform friends and matchmaking rely on. As Epic’s own onboarding documentation puts it, this approach “enables you to use a single back-end service provider for authentication, social, and game functionality, leaving more time to focus on building what makes your game unique.”

EOS_HConnect ConnectHandle = EOS_Platform_GetConnectInterface(PlatformHandle);

EOS_Connect_Credentials ConnectCredentials = {};
ConnectCredentials.ApiVersion = EOS_CONNECT_CREDENTIALS_API_LATEST;
ConnectCredentials.Token = PlatformSpecificToken; // e.g. Steam session ticket
ConnectCredentials.Type = EOS_EExternalCredentialType::EOS_ECT_STEAM_SESSION_TICKET;

EOS_Connect_LoginOptions LoginOptions = {};
LoginOptions.ApiVersion = EOS_CONNECT_LOGIN_API_LATEST;
LoginOptions.Credentials = &ConnectCredentials;

EOS_Connect_Login(ConnectHandle, &LoginOptions, nullptr, OnConnectLoginComplete);

void OnConnectLoginComplete(const EOS_Connect_LoginCallbackInfo* Data) {
    if (Data->ResultCode == EOS_EResult::EOS_Success) {
        EOS_ProductUserId LocalUserId = Data->LocalUserId;
        // Store LocalUserId - every other EOS call needs it
    } else if (Data->ResultCode == EOS_EResult::EOS_InvalidUser) {
        // No Epic account linked yet - offer EOS_Connect_CreateUser
    }
}

Note the branch for EOS_InvalidUser: the first time a given external account (Steam, console, or otherwise) connects, EOS has no linked Product User ID for it yet. Your callback needs to call EOS_Connect_CreateUser in that case to mint one, then retry the login. Skipping this branch is a common cause of new players getting stuck on a “failed to sign in” screen while returning players sign in without issue.

Step 8: Add Friends, Presence, and Lobbies

Lobbies are how most teams implement pre-match grouping: forming a party, selecting a game mode, and exchanging attributes like ready-state before a match starts. Unlike Sessions, Lobbies are hosted persistently by Epic’s backend rather than by a player acting as host, and they include built-in real-time voice chat through EOS RTC if you enable it on lobby creation.

EOS_HLobby LobbyHandle = EOS_Platform_GetLobbyInterface(PlatformHandle);

EOS_Lobby_CreateLobbyOptions CreateOptions = {};
CreateOptions.ApiVersion = EOS_LOBBY_CREATELOBBY_API_LATEST;
CreateOptions.LocalUserId = LocalUserId;
CreateOptions.MaxLobbyMembers = 4;
CreateOptions.PermissionLevel = EOS_ELobbyPermissionLevel::EOS_LPL_JOINVIAPRESENCE;
CreateOptions.bPresenceEnabled = EOS_TRUE;
CreateOptions.bAllowVoiceChat = EOS_TRUE;

EOS_Lobby_CreateLobby(LobbyHandle, &CreateOptions, nullptr, OnLobbyCreated);

Once a lobby exists, other players in the local user’s friends list who are shown as “in a lobby” through presence can join directly from their friends list overlay, without needing an invite link or a shared code. That presence-driven join flow is one of the more polished parts of EOS out of the box, and it is the same mechanism SDK 1.18’s Localized Presence update extended to show status text translated into the viewing player’s language rather than the host’s.

Step 9: Set Up Sessions and Matchmaking

Where Lobbies handle pre-match grouping, Sessions handle the actual match: a client-authoritative or dedicated-server-hosted game session that other players can discover and join through search filters, similar to a traditional server browser. Epic’s help documentation frames it plainly: EOS “offers free matchmaking services in two flavors” — Sessions for structured, filterable match discovery, and Lobbies for social, presence-driven grouping.

EOS_HSessions SessionsHandle = EOS_Platform_GetSessionsInterface(PlatformHandle);

EOS_Sessions_CreateSessionModificationOptions ModOptions = {};
ModOptions.ApiVersion = EOS_SESSIONS_CREATESESSIONMODIFICATION_API_LATEST;
ModOptions.SessionName = "GameSession1";
ModOptions.BucketId = "Region:NA-East|Mode:Deathmatch";
ModOptions.MaxPlayers = 8;
ModOptions.LocalUserId = LocalUserId;
ModOptions.bPresenceEnabled = EOS_TRUE;

EOS_HSessionModification SessionModHandle = nullptr;
EOS_Sessions_CreateSessionModification(SessionsHandle, &ModOptions, &SessionModHandle);
EOS_SessionModification_SetJoinInProgressAllowed(SessionModHandle, &JoinInProgressOptions);
EOS_Sessions_UpdateSession(SessionsHandle, &UpdateOptions, nullptr, OnSessionUpdated);

The BucketId field is worth calling out specifically: it is a free-form string Epic recommends structuring as a pipe-delimited set of key-value pairs (region, game mode, map, skill bracket) so that a session search can filter on it efficiently. Teams that leave it as a generic constant across every session type end up building slow, unfiltered searches that scan far more sessions than necessary once player counts grow past a few hundred concurrent matches.

Step 10: Add Achievements, Stats, and Leaderboards

Achievements and leaderboards are configured partly in the Developer Portal (defining the achievement IDs, unlock conditions metadata, and leaderboard definitions) and partly in code (actually unlocking achievements and submitting stats as players progress). Define your achievement and stat IDs in the portal first, matching the exact string identifiers you will reference from your client.

EOS_HAchievements AchievementsHandle = EOS_Platform_GetAchievementsInterface(PlatformHandle);

EOS_Achievements_UnlockAchievementsOptions UnlockOptions = {};
UnlockOptions.ApiVersion = EOS_ACHIEVEMENTS_UNLOCKACHIEVEMENTS_API_LATEST;
UnlockOptions.UserId = LocalUserId;
const char* AchievementIds[] = { "FIRST_WIN" };
UnlockOptions.AchievementIds = AchievementIds;
UnlockOptions.AchievementsCount = 1;

EOS_Achievements_UnlockAchievements(AchievementsHandle, &UnlockOptions, nullptr, OnAchievementUnlocked);

Stats work similarly through the Stats interface, and leaderboards read from stats you have already submitted rather than being written to directly — you configure a leaderboard definition in the portal that aggregates a given stat (highest score, fastest time, total kills) and EOS handles the ranking and pagination when a client queries it.

Step 11: Enable Player Data Storage and Title Storage

Player Data Storage gives each authenticated player a private cloud file store — the equivalent of Steam Cloud saves, but portable across whichever platform the player logs in from. Title Storage is the inverse: read-only files your game reads at runtime that you control centrally, useful for shipping remote configuration, event schedules, or balance data without pushing a client update.

• Use Player Data Storage for save files, settings, and progress you want synced across a player’s devices
• Use Title Storage for data you want to change without a client patch, such as a live-ops event calendar
• Both interfaces work with chunked uploads and downloads, so large files do not need to be loaded fully into memory before transfer
• Neither replaces a full backend database — they are file-oriented stores, not queryable tables, so relational player data still needs a service like PlayFab, DynamoDB, or your own database behind a thin API

Step 12: Integrate Easy Anti-Cheat

Easy Anti-Cheat ships alongside the EOS SDK rather than as a fully separate product. Per Epic’s Easy Anti-Cheat services documentation, you download the same EOS SDK for PC, Android, or iOS, with console SDKs available through their respective developer portals after requesting access — the anti-cheat client and bootstrapper come bundled with that download rather than requiring a second integration path.

• Add the EAC client module to your game binary and configure your Product ID and Deployment ID so EAC can validate against the correct EOS product
• Ship the EAC bootstrapper with your installer so it can install or update the anti-cheat client on a player’s machine automatically
• On Windows, EAC now supports Arm-native devices — SDK 1.17.1.3, shipped in August 2025, introduced an Arm-native EAC client and an Arm-aware bootstrapper so EAC-protected titles can run on Snapdragon-powered Windows PCs without falling back to emulation
• Validate server-side that a connecting client’s EAC status is genuinely active before trusting gameplay-affecting data from that client — client-side anti-cheat checks alone are not a substitute for server authority on anything that matters competitively

Epic used Fortnite as the first production title to validate the Arm-native EAC rollout before extending it to other EAC-protected games, which is a useful signal for how conservatively Epic tends to stage anti-cheat changes — expect similar staged rollouts for future EAC platform expansions rather than a single big-bang release across every supported title at once.

Step 13: Test Cross-Platform Play and Go Live

With Connect, Lobbies, Sessions, achievements, storage, and EAC wired up against your dev sandbox, run a full cross-platform test pass before switching your shipping build over to the live deployment. At minimum, verify: two different external account types (for example, a Steam account and a device-local anonymous login) can see each other as friends and join the same lobby; a session created on one platform is discoverable and joinable from another; achievement unlocks and leaderboard submissions show up correctly in the portal’s live data view; and EAC reports an active status for a fully patched client.

Once that pass is clean, update your build configuration to point at the live deployment’s Client ID, Client Secret, and Deployment ID, and ship. Keep the dev sandbox around permanently for future feature work — you will need it again the first time you add a new achievement or session type after launch.

Building a Complete Working Project: A Minimal Cross-Platform Lobby Demo

To tie the previous thirteen steps together, here is the skeleton of a minimal but complete project: a desktop client that authenticates through Connect, creates or joins a lobby, and unlocks an achievement the first time two players are in the same lobby together. This is intentionally small — it omits UI code and error-recovery edge cases — but every call in it maps directly to a step above.

// 1. Initialize SDK and create platform handle (Step 6)
EOS_Initialize(&InitOptions);
EOS_HPlatform PlatformHandle = EOS_Platform_Create(&PlatformOptions);

// 2. Authenticate via Connect (Step 7)
EOS_Connect_Login(ConnectHandle, &LoginOptions, nullptr, OnConnectLoginComplete);

// 3. On successful login, create or join a lobby (Step 8)
void OnConnectLoginComplete(const EOS_Connect_LoginCallbackInfo* Data) {
    if (Data->ResultCode == EOS_EResult::EOS_Success) {
        g_LocalUserId = Data->LocalUserId;
        EOS_Lobby_CreateLobby(LobbyHandle, &CreateOptions, nullptr, OnLobbyCreated);
    }
}

// 4. When a second member joins, unlock an achievement (Step 10)
void OnLobbyMemberUpdateReceived(const EOS_Lobby_LobbyMemberUpdateReceivedCallbackInfo* Data) {
    uint32_t MemberCount = EOS_Lobby_GetMemberCount(LobbyHandle, &MemberCountOptions);
    if (MemberCount >= 2) {
        const char* AchievementIds[] = { "FIRST_SQUAD" };
        UnlockOptions.AchievementIds = AchievementIds;
        UnlockOptions.AchievementsCount = 1;
        EOS_Achievements_UnlockAchievements(AchievementsHandle, &UnlockOptions, nullptr, OnAchievementUnlocked);
    }
}

// 5. Tick the platform every frame (required, see Step 6)
void GameLoop() {
    EOS_Platform_Tick(PlatformHandle);
}

Compile this against two separate machines (or two instances on the same machine using different local ports if your engine supports that for testing) and log in with two different external accounts. If both clients can see the “FIRST_SQUAD” achievement unlock fire once they are in the same lobby, every core piece of the EOS pipeline — Connect authentication, Lobby membership events, and Achievements — is wired correctly, and the rest of your integration is additive from here.

Common Pitfalls When Integrating Epic Online Services

Most EOS integration problems trace back to a small set of recurring mistakes. Knowing them up front saves hours of confused debugging.

• Forgetting to call EOS_Platform_Tick every frame. EOS processes callbacks cooperatively rather than on background threads, so a missing tick call makes every asynchronous operation appear to hang forever with no error surfaced.
• Mixing up sandbox and deployment IDs between the dev and live environments. A client built against dev credentials but pointed at a live deployment ID (or vice versa) authenticates against the wrong data set and looks broken in ways that have nothing to do with your actual game logic.
• Skipping the EOS_InvalidUser branch on first login. The first time a given external account connects, EOS has no Product User ID for it yet, and skipping the EOS_Connect_CreateUser call in that branch leaves first-time players unable to sign in while returning players work fine.
• Using generic or empty Session BucketId values. A flat bucket ID across every game mode and region forces session search to scan far more results than necessary, which becomes a real latency problem once you have more than a few hundred concurrent sessions.
• Treating client-reported Easy Anti-Cheat status as sufficient validation. EAC raises confidence that a client is unmodified, but competitively meaningful state should still be validated or computed server-side — a client-only trust model defeats much of the point of running anti-cheat at all.

Troubleshooting Epic Online Services Issues

The following are the issues developers run into most often when bringing up a new EOS integration, along with what typically causes each one.

Symptom	Likely Cause	Fix
EOS_Platform_Create returns a null handle	Incorrect Product ID, Sandbox ID, or Deployment ID	Re-copy all four identifiers directly from the Developer Portal; do not retype them by hand
Login callback never fires	Missing EOS_Platform_Tick call in the game loop	Call EOS_Platform_Tick(PlatformHandle) once per frame unconditionally
Connect login returns EOS_InvalidUser	No Product User ID exists yet for this external account	Call EOS_Connect_CreateUser in that branch, then retry login
Lobby search returns zero results	Bucket ID mismatch between the searching client and the created lobby	Standardize your Bucket ID format across every code path that creates or searches lobbies
Friends list shows no presence status	Presence not enabled when the lobby or session was created	Set bPresenceEnabled to true on lobby or session creation options
Achievements do not appear unlocked in the portal	Achievement ID string mismatch between portal config and client code	Confirm the exact-match string ID configured in the portal matches your AchievementIds array
Easy Anti-Cheat reports client not protected	EAC bootstrapper did not run or the client binary is not linked against the EAC module	Confirm the bootstrapper ships with your installer and that your build links the EAC client library
Requests fail intermittently under load testing	Client exceeding per-interface rate limits	Batch calls where the API supports it and add exponential backoff on retry logic

If none of the above match what you are seeing, check Epic’s EOS release notes for a known-issue entry tied to the specific SDK build you are running — Epic documents breaking changes and interim workarounds there ahead of the next stable release.

Advanced Tips: Scaling an EOS Integration in Production

Once the basic integration is live, a few practices separate a fragile setup from one that holds up as your player base grows. First, treat your Bucket ID scheme as a schema, not a string — document it, version it, and never silently change its format once players have live sessions using the old one, or search will fail for anyone still connected to a session tagged the old way. Second, cache Product User ID lookups aggressively on your own backend if you run one; resolving external account IDs to Product User IDs repeatedly for the same player wastes calls against EOS’s rate limits for no benefit. Third, if your game spans PC, console, and mobile, budget extra QA time specifically for the console SDK approval and integration path, since it runs on a separate timeline from the public PC/Android/iOS downloads and is frequently the long pole in a cross-platform launch schedule.

Finally, pair EOS with a dedicated server-hosting layer rather than expecting it to replace one. EOS Sessions can be configured around either peer-hosted or dedicated-server-backed matches, but EOS itself does not provision or scale the server processes — that is a job for something like Agones on Kubernetes or a managed fleet service, with EOS handling identity, discovery, and social features on top. Teams that try to make EOS do both jobs at once tend to end up fighting the SDK instead of shipping features.

How EOS Fits Alongside Console Crossplay Requirements

If cross-platform play across Xbox, PlayStation, and Switch is a launch requirement rather than a nice-to-have, EOS’s Connect and Epic Account Services layers do most of the identity-linking work, but each platform holder still imposes its own certification requirements around crossplay opt-in, parental controls, and account linking flows. Our breakdown of crossplay support across Xbox, PS5, and Switch 2 is worth reviewing alongside this integration, since platform-specific certification checklists change independently of anything EOS itself controls, and missing one during console submission is a common cause of last-minute launch delays that have nothing to do with your EOS integration being broken.

It is also worth deciding early whether EOS will be your only backend or one layer among several. Studios shipping on Steam alongside the Epic Games Store often run EOS for cross-platform identity while still supporting native Steamworks features for their Steam build specifically — our comparison of Steam, Epic, and GOG covers the store-level differences that shape which native features are worth maintaining in parallel with an EOS integration.

EOS Web APIs and Backend-to-Backend Calls

Everything covered so far runs from inside your game client through the native SDK, but EOS also exposes a set of Web APIs intended for server-to-server use — calls your own backend makes directly over HTTPS rather than through a compiled client. The Friends Web APIs added in SDK 1.18 are a good example: a backend service can query a player’s Epic friends graph without needing to embed the full native SDK, which matters if you are building a companion website, a support tool, or a moderation dashboard that needs read access to social data without shipping a game client.

Web API calls use OAuth-style client credentials rather than the Product User ID flow your game client uses, and Epic explicitly separates “client” policy credentials (safe to embed in a shipped binary) from “server” or “web API” policy credentials (which must stay on infrastructure you control). If you generate a Web API credential and accidentally embed it in a client build, treat it as compromised immediately and rotate it from the Developer Portal — unlike a client-policy Client Secret, a leaked server-policy credential can expose backend-only operations Epic assumes only your own infrastructure will call.

Practical uses for the Web API path include syncing player achievement or leaderboard data into an external analytics pipeline, powering a companion app that shows a player’s stats without launching the game, and building internal moderation tooling that needs to query session or lobby state without instrumenting every internal tool as a full EOS client. Most studios do not need this on day one, but it is worth knowing it exists before you reach for a third-party service to solve a problem EOS’s own Web APIs already cover.

Frequently Asked Questions

Is Epic Online Services really free?

Yes. Epic’s own product page states the services are available “all for free,” and there is no published per-MAU, per-API-call, or bandwidth pricing tier for the core EOS feature set. Your only real cost is the infrastructure you run yourself for anything EOS does not provide directly, such as dedicated game servers.

Do I need to sell my game on the Epic Games Store to use EOS?

No. EOS is engine- and store-agnostic by design. You can ship on Steam, a console storefront, or your own launcher and still integrate EOS for cross-platform identity, matchmaking, and anti-cheat.

What is the difference between EOS Sessions and EOS Lobbies?

Sessions represent the actual match and are discoverable through filterable search, similar to a server browser. Lobbies represent pre-match grouping — parties, ready-checks, mode selection — and are hosted persistently by Epic’s backend with built-in presence and optional voice chat.

Does EOS work with Unity, or only Unreal Engine?

EOS works with Unity through Epic’s Unity plugin and with any custom engine through the native C/C++ SDK. Unreal Engine gets the deepest first-party integration since Epic maintains both products, but EOS was explicitly designed to be engine-agnostic.

Can I use EOS on Windows-on-Arm devices?

Yes, as of SDK 1.17.1.3, released in August 2025, which added an Arm-native Easy Anti-Cheat client and bootstrapper. Epic tested this rollout with Fortnite before extending it to other EAC-protected titles, so confirm your specific SDK build includes Arm support before assuming it is available.

Does EOS include dedicated server hosting?

No. EOS handles identity, matchmaking, social features, and anti-cheat, but it does not provision or scale dedicated game server fleets. Teams typically pair EOS with a separate server-hosting layer, such as a Kubernetes-based setup or a managed fleet service, for the actual authoritative game server processes.

How do I get console SDKs for PlayStation, Xbox, or Switch?

Console SDKs are not part of the public PC, Android, and iOS download. You need to request access through each platform’s own developer portal, which typically requires an existing registered developer account with that platform holder, separate from your Epic Games developer account.

What happens if I mix up my dev and live deployment credentials?

Your client authenticates successfully but against the wrong data set, since dev and live sandboxes maintain entirely separate player, achievement, and session data. This is one of the most common sources of “it works on my machine but not for players” bug reports during a launch, so double-check which deployment ID is baked into any build before shipping it.

Related Coverage

• Amazon GameLift Streams Setup: 12 Steps, $0.50/Hr [2026]
• Kubernetes Ingress Setup: 12 Steps After NGINX EOL [2026]
• AWS Security Hub CSPM Setup: $0.001/Check, 12 Steps [2026]
• PlayFab Multiplayer Servers Setup: 12 Steps, 90 Min [2026]
• AWS Lambda MicroVMs Setup: 12 Steps, 4x Peak Scaling [2026]