Title Storage

Title Storage provides read-only access to files uploaded through the EOS Developer Portal. Use it for game configurations, patch data, or any shared content that all players should access.

Title Storage files are read-only from the game. Upload and manage files through the EOS Developer Portal.

Files are encrypted. You must configure the encryption key in EIK Settings to match the key used when uploading.

Portal Setup

Go to the EOS Developer Portal
Navigate to Game Services → Title Storage
Click + New Title Data
Generate an Encryption Key (64 hex characters) using a generator like numbergenerator.org
Upload your file and optionally add tags for filtering

Copy the encryption key to your EIK Settings in Unreal Engine. Without it, files cannot be decrypted.

Enumerate Files

List all available title storage files.

Copy and paste into Unreal Engine Blueprint editor

Tag (optional): Filter files by tag (empty = all files)

Returns an array of file metadata including filename and size.

#include "EIKCore/Public/Interfaces/IEIKTitleFile.h"

void UMyClass::ListTitleFiles()
{
    TSharedPtr<IEIKTitleFile> TitleFile = GetTitleFileInterface();
    if (!TitleFile.IsValid()) return;

    FEIKEnumerateTitleFilesParams Params;
    // Params.Tags.Add(TEXT("config")); // Optional tag filter

    TitleFile->EnumerateFiles(0, Params,
        FEIKAsyncCallback<FEIKEnumerateTitleFilesResult>::CreateLambda(
            [](const TEIKAsyncResult<FEIKEnumerateTitleFilesResult>& Result)
            {
                if (Result.IsSuccessful())
                {
                    for (const FEIKTitleFileMetadata& File : Result.GetValue().Files)
                    {
                        UE_LOG(LogTemp, Log, TEXT("%s (%lld bytes)"),
                            *File.Filename, File.FileSizeBytes);
                    }
                }
            }));
}

#include "Online/OnlineServices.h"
#include "Online/TitleFile.h"

using namespace UE::Online;

void UMyClass::ListTitleFiles()
{
    IOnlineServicesPtr Services = GetServices(EOnlineServices::Epic);
    ITitleFilePtr TitleFile = Services->GetTitleFileInterface();

    FTitleFileEnumerateFiles::Params Params;
    Params.LocalAccountId = GetLocalAccountId();

    TitleFile->EnumerateFiles(MoveTemp(Params))
        .OnComplete([](const TOnlineResult<FTitleFileEnumerateFiles>& Result)
        {
            if (Result.IsOk())
            {
                UE_LOG(LogTemp, Log, TEXT("Title files enumerated"));
            }
        });
}

#include "OnlineSubsystem.h"
#include "Interfaces/OnlineTitleFileInterface.h"

void UMyClass::ListTitleFiles()
{
    IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get(FName(TEXT("EIK")));
    IOnlineTitleFilePtr TitleFile = OnlineSub->GetTitleFileInterface();

    FPagedQuery Page;
    TitleFile->EnumerateFiles(Page);

    TitleFile->AddOnEnumerateFilesCompleteDelegate_Handle(
        FOnEnumerateFilesCompleteDelegate::CreateLambda(
            [TitleFile](bool bWasSuccessful, const FString& Error)
            {
                if (bWasSuccessful)
                {
                    TArray<FCloudFileHeader> Files;
                    TitleFile->GetFileList(Files);

                    for (const FCloudFileHeader& File : Files)
                    {
                        UE_LOG(LogTemp, Log, TEXT("%s (%d bytes)"),
                            *File.FileName, File.FileSize);
                    }
                }
            }));
}

Read File

Download and read a title storage file.

Copy and paste into Unreal Engine Blueprint editor

Filename: Name of the file to read
File Data (output): Raw bytes of the file content

void UMyClass::LoadTitleFile(const FString& Filename)
{
    TSharedPtr<IEIKTitleFile> TitleFile = GetTitleFileInterface();

    FEIKReadTitleFileParams Params;
    Params.Filename = Filename;

    TitleFile->ReadFile(0, Params,
        FEIKAsyncCallback<FEIKReadTitleFileResult>::CreateLambda(
            [](const TEIKAsyncResult<FEIKReadTitleFileResult>& Result)
            {
                if (Result.IsSuccessful())
                {
                    const TArray<uint8>& Data = Result.GetValue().FileContents.Data;
                    FString Content = FString(UTF8_TO_TCHAR(
                        reinterpret_cast<const char*>(Data.GetData())));
                    UE_LOG(LogTemp, Log, TEXT("Content: %s"), *Content);
                }
            }));
}

void UMyClass::LoadTitleFile(const FString& Filename)
{
    ITitleFilePtr TitleFile = GetTitleFileInterface();

    FTitleFileReadFile::Params Params;
    Params.LocalAccountId = GetLocalAccountId();
    Params.Filename = Filename;

    TitleFile->ReadFile(MoveTemp(Params))
        .OnComplete([](const TOnlineResult<FTitleFileReadFile>& Result)
        {
            if (Result.IsOk())
            {
                const TArray<uint8>& Data = *Result.GetOkValue().FileContents;
                // Process file data
            }
        });
}

void UMyClass::LoadTitleFile(const FString& Filename)
{
    IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get(FName(TEXT("EIK")));
    IOnlineTitleFilePtr TitleFile = OnlineSub->GetTitleFileInterface();

    TitleFile->ReadFile(Filename);

    TitleFile->AddOnReadFileCompleteDelegate_Handle(
        FOnReadFileCompleteDelegate::CreateLambda(
            [TitleFile](bool bWasSuccessful, const FString& FileName)
            {
                if (bWasSuccessful)
                {
                    TArray<uint8> FileData;
                    TitleFile->GetFileContents(FileName, FileData);
                    // Process file data
                }
            }));
}

Common Use Cases

Use Case	Example
Game Config	Balance values, difficulty settings
Patch Notes	Version info displayed in-game
Event Data	Limited-time event configurations
Asset Lists	URLs for downloadable content
Localization	Text overrides without app update

Helper Functions

The EIK Title File Library provides utilities:

Function	Description
`TitleFileBytesToString`	Convert file bytes to string
`TitleFileBytesToJsonString`	Convert file bytes to JSON string
`ParseTitleFileAsConfig`	Parse as key-value config (TMap)
`ParseTitleFileAsLines`	Parse as line array