brainCloud 6.0.1 is a bigger release than the version number suggests.

This release includes a comprehensive set of analytics for the new LiveOps Campaign feature. It also includes configuration improvements for Apple Push Notifications, the ability to deploy individual Custom Entity collections, key authentication-related security improvements, and more.

This is a server-side update only. No changes to client libs or client APIs.

Compatibility Notes

We prioritize preserving stability and backward compatibility for existing apps. App compatibility flags are located under App > Design > Core App Info > Advanced Settings; each is enabled to preserve existing behavior for existing apps, but disabled by default for new apps.

New compatibility flags in 6.0.1 [all default to enabled for existing apps]:

• [x] Support legacy Google OpenID authentication (less secure, not recommended) - retains the older, less secure authentication path. Highly recommended that all apps disable.
• [x] Support legacy Facebook Limited authentication (less secure, not recommended) - retains the older, less secure authentication path. Highly recommended that all apps disable.
• [x] Support legacy Nintendo authentication (less secure, not recommended) - retains the older, less secure authentication path. Highly recommended that all apps disable. IMPORTANT - requires Nintendo Client ID to be set on App > Design > Core App Info > Application IDs page, Nintendo tab.

Compatibility flags already present from 6.0.0 [all default to enabled for existing apps]

• [x] Support legacy Game Center authentication (less secure, not recommended) - retains the older Game Center auth path. Note - requires client changes and the brainCloud 6.0 client libs.
• [x] Support legacy Steam authentication (uses deprecated Steam ticket API - less secure) - Retains the older Steam authentication path as we move to the modern, non-deprecated Steam APIs. Note that the new modern API requires devs to configure a new Steam Identity field on the App > Design > Core App Info > Application IDs page. Does not require updated brainCloud Client Lib.
• [x] Support legacy segmentIds in Cloud Code Script APIs - Enabled by default, so existing scripts keep working; disable it to require segment codes in your Cloud Code scripts and reject numeric IDs.

Release Highlights

LiveOps Campaign Analytics

The primary purpose of 6.0.1 is to provide the LiveOps Campaign Analytics screen, which was missing in the initial 6.0 release. 

The screen can be found under App > Reports > Analytics > LiveOps Campaigns and has some great features:

• It summarizes the campaign activity and provides charts for:

  • Active Participants
  • New Participants
  • Purchasers
  • Total Revenue
  • Total Playtime
  • Item Sales
  • Cash Product Sales
  • Session Duration
  • Daily Playtime
  • Revenue per active User
  • Retention
• When valid, the system mathematically assesses changes against the control scenario (or B and C against the A scenario if control is absent) to determine the statistical significance of those changes.
• Significance tests default to 95% - but 80, 85, 90, and 99% tests are available as well.
• If there isn’t enough data to be confident about significance, the system advises how many more days of data are required.
• brainCloud also allows the portal user to store Notes against the campaign - for instance, how and why a scenario was chosen as the winner in an a/b test.
• The Optimize Campaign button allows the developer to reallocate all future participants to the “winning” scenario to optimize performance for the remainder of the campaign.

brainBot Changes

brainBot has been enhanced to understand LiveOps Campaign analytics. brainBot is especially useful when you want to take a deep dive into the numbers of an a/b test campaign.

brainBot can even write a report that can be placed in the Notes section of a campaign to summarize the results of your a/b campaign.

Note that we are also turning off the Super! power mode for brainBot. Our tests show that within brainCloud the Smart mode (which uses Sonnet) performs as well as Super! (which uses Opus) - but is 5x cheaper!

Authentication Security Improvements

We have improved the security checks performed by Google OpenID, Facebook Limited, and Nintendo authentication.

In theory, you should be able to disable the associated compatibility flags and automatically benefit from these improvements [except for Nintendo authentication, which requires the Nintendo Client ID to be filled in the Nintendo section of the App > Design > Core App Info > Application IDs page].

Provided your app is already sending the correct parameters during authentication, no changes to the game client should be required.

We recommend that devs do a quick test in the development version of their apps first, though - better safe than sorry!

Apple Token Based (.p8) Push Notifications

We now support Apple’s token-based (.p8) signing keys as an alternative to .p12 certificates. The advantage is that these don’t expire every 12 months!

To move to the new Token Based push notification settings:

• Navigate to the App > Design > Notifications > Settings page
• If necessary, Unlock your app
• Select Apple platform - and click [View…] and then [Edit]
• Select Token Based (.p8) for Authentication Type
• Fill in the required fields
• Hit [Save]

Custom Entity-only Deployments

The Deployment screen now includes a new tab for deploying individual custom entity collections. The standard Deployment still automatically migrates all custom entity collections configured as migrateable, but this new feature lets developers refresh selected custom entity collections in the downstream environment WITHOUT doing a FULL deploy.

This support has also been added to the Builder API.

Other Improvements

Additional improvements:

• Signin with Apple improvements - now supports sign-in over non-Apple devices, by allowing devs to configure a comma-delimited list of Services IDs.
• Campaign attribution for Cash Product Purchases
• New User Item and LiveOps Campaign DataStream Events
• SysRecordTransaction was incorrectly recording the “given” price as the “regularPrice” – which is misleading when promotions are active. Fixed.
• New App Alerts - new alerts trigger if apps are exceeding the DAU and Account maximums for limited plans (i.e. Dev and Dev+).

Portal Changes

In addition to the new LiveOps Reporting, there have been a number of other improvements to the Portal:

• App > Calendar - improved calendar display and navigation to related service screens

• App > Design > Core App Info > Application IDs

  • Apple tab - new Signin Services IDs field, which supports Signin for Apple on non-Apple devices
  • Nintendo tab - new client ID field for improved authentication security
• App > Design > Admin Tools > Deployment - new Custom Entities Only deployment tab.
• App > Design > Files > Global Files - we now support importing and exporting individual file folders.
• App > Design > LiveOps > LiveOps Campaigns - improved screen and list presentation - and added ability to easily clone campaigns.
• App > Design > Notifications > Settings - support for Apple Token-based Push Notification configuration
• App > Reports > Analytics > LiveOps Campaigns - the new LiveOps Campaign Analytics
• User > User Browser - added support to browse for users in LiveOps Campaigns
• User > Data > Attributes - improved usability of the screen

We also made a bunch of improvements to charts across the system:

• Improved presentation of dates on the x-axis
• Added “stacked” toggle option for many of the bar charts

API Changes

We have added the following new cloud-code-only APIs to the system:

• AppStore - new SysRecordTransactionAdvanced() call supports inclusion of campaign info.
• Campaign - added two new sys calls for updating the custom JSON configurations for campaigns and scenarios: SysUpdateCampaignJson() and SysUpdateScenarioJson()
• RedemptionCode - new SysTestRedeemCode() call allows testers to redeem against a future-dated Redemption campaign without moving the start date

brainBot isn't the only piece of AI goodness that we've had cooking - introducing the new brainCloud MCP Server!

Summary

Connect AI tools directly to your brainCloud account to manage apps, write and deploy cloud code, configure hooks, and S2S servers - all through natural language. Now available with a local Helper for two-way cloud code sync.

Details

We're excited to introduce the brainCloud MCP (Model Context Protocol) Server - a new way to connect AI tools directly to your brainCloud account.

Once connected, you can manage your brainCloud apps entirely through natural language. Ask your AI to write and deploy cloud code scripts, configure API hooks, manage S2S servers, explore the brainCloud API, run scripts, and even help build your client-side integrations.

Before you start

Your team must have the Builder API enabled before you can connect. A team admin can turn it on under Team > Setup > Team Info. There's nothing else to provision — no static API keys are required; you simply sign in with your brainCloud credentials.

What you can do

• List, read, create, and edit cloud code scripts - e.g., “Create a cloud code script that posts a score to multiple leaderboards.”
• Manage API hooks - e.g., “Add a pre-hook for posting leaderboard scores.”
• Configure S2S servers - e.g., “List my S2S servers.”
• Explore the brainCloud API - Your AI looks up the live documentation for your instance and verifies every method signature before writing a script.
• Run and test scripts - e.g., “Test the AwardCoins script.”
• Get help with client integration - the MCP's knowledge of the API helps you write your client apps too.

Easy, secure setup

The MCP server is hosted (HTTP/SSE) and uses OAuth - just add it as a connector in your AI tool and sign in with your brainCloud credentials. No static API keys required. The Public BaaS endpoint is https://mcp.braincloudservers.com/mcp.

Live app safety

Apps on a live plan are protected by brainCloud's live-lock feature. Your AI will notify you if an app is live-locked and ask you to confirm an unlock through the brainCloud portal before making any write operations.

Sync cloud code to local files

Pair the hosted server with the new brainCloud MCP Helper - a small, trustless companion that runs locally and lets your AI sync your cloud code scripts between brainCloud and a folder on your machine (pull, push, or full two-way sync with automatic merging). It stores no credentials, and your script data flows directly between your machine and brainCloud, never through the AI.

To install

Follow our step-by-step guides to get started:

• Getting Started with brainCloud MCP in Claude
• Syncing Cloud Code to Local Files with the brainCloud MCP Helper

Note: the brainCloud MCP is built and tested using Claude CLI and Claude Desktop, but we are adding support for additional MCP-compatible services. If you find your service doesn't work, contact us via support!

Our new AI assistant, brainBot, will totally transform how you use brainCloud. Super-capable and always available, brainBot makes everything faster and easier!

brainCloud 6.0 also includes the beta of our brand-new LiveOps Campaigns system, Group Tournaments, i3D Flex Metal hosting, Godot GDScript Support, 60-Day Retention analytics, visionOS support, and a long list of marketplace, multiplayer, and portal improvements. There's a lot here - let's dig in!

Given the large changes in this release, we have updated our legal and policy documents to reflect what brainCloud 6 actually does. These updates take effect Monday, June 22, 2026.  See the Updated Terms of Service section at the end of these notes for more details.

Compatibility Notes

We prioritize preserving stability and backward compatibility for existing apps. App compatibility flags are located under App > Design > Core App Info > Advanced Settings; each is enabled to preserve existing behavior for existing apps, but disabled by default for new apps.

New compatibility flags in 6.0 [all default to enabled for existing apps]

• [x] Support legacy Game Center authentication (less secure, not recommended) - retains the older Game Center auth path. Note - requires client changes and the brainCloud 6.0 client libs.
• [x] Support legacy Steam authentication - Retains the older Steam authentication path as we move to the modern, non-deprecated Steam APIs. Note that the new modern API requires devs to configure a new Steam Identity field on the App > Design > Core App Info > Application IDs page.Does not require updated brainCloud Client Lib.
• [x] Support legacy segmentIds in Cloud Code Script APIs - Enabled by default, so existing scripts keep working; disable it to require segment codes in your Cloud Code scripts and reject numeric IDs.  

Carried over from a 5.9 patch (listed here because 6.0 is the first full release to include it):

• [x] Do not strictly validate universalIds received via API endpoints (less secure, not recommended) - universalIds received via API are now sanitized and strictly validated; this flag preserves the looser legacy behavior

Release Highlights

Meet brainBot - your new team member!

The marquee feature of release 6.0 is brainBot, a Claude-powered AI assistant that lives inside the Design Portal. brainBot knows brainCloud, sees your screen, answers questions, writes and debugs scripts, and, with your permission, takes action on your apps.

What can brainBot do?

• Navigation - brainCloud can help you quickly navigate to the right screen or end-user account.
• Answer & Guide - context-aware help that reads the current screen, fetches the right docs/API references on demand, and walks you through tasks step-by-step.
• Write Scripts - brainCloud understands cloud code syntax and APIs and can write scripts for you. Even better, brainBot helps you test and debug interactively!
• Feature Setup - feature configuration can sometimes be tedious. Need to extend your XP level cap from 30 → 40? Adjust the slope of the XP curve? Let brainBot do it for you!
• Translate - brainBot can fill in missing localizations for your Item Catalog, Cash Products, and Promotions.
• Collaborate - brainBot helps you fill in the gaps in your inventory of Cash Products, Items, and Bundles. 
• LiveOps - brainBot can help you set up new Promotions, Redemption Codes, and even LiveOps Campaigns!
• Work with files - upload text files into a conversation and have brainBot generate text files for you. Allows brainBot to work with and/or generate design docs, simple import/export files, etc.

Built for trust & safety:

• Your data stays private - your app and user data is not used for training purposes. 
• Personally Identifiable Information (PII) - by default, PII is stripped before being sent to the AI provider. brainBot resolves PII tokens on the portal side, so player names and emails are shown to you without the provider ever seeing them.
• Team governance - admins control brainBot at the team and per-app level, set default restrictions (over app and user data), and configure daily/monthly cost caps.
• Portal permissions - brainBot has at most the same permissions as the portal user. If the user doesn’t have permission to edit cloud code scripts, then brainBot doesn't either. brainBot is also gated by brainCloud Live Lock feature.
• Per-app context - teams can give brainBot custom context on an app-by-app basis, so its help is tailored to your app.

Availability & costs:

• brainBot is an opt-in feature available on all paid plans (Dev+ or higher).
• AI Usage - the app charges a 35% markup on token costs for processed requests. Admins can set daily and monthly soft caps.
• Auto "power" tiers - brainBot automatically scales its model/tooling to the task, so simple questions stay fast, and complex ones get more horsepower. And this saves $ too!

Go to Team > Setup > AI Settings to enable brainBot!

LiveOps Campaigns [Beta] ENTERPRISE

brainCloud 6.0 introduces LiveOps Campaigns - a powerful new way to run targeted, time-boxed promotions and personalized pricing on top of our Segments and Promotions systems.

• Create & schedule campaigns with a guided creation Wizard, status tracking, and segment targeting.
• Personalized pricing - the AppStore service now returns each user's eligible campaigns alongside promotions, ensuring the right offer reaches the right player.
• Cash-product & item overrides are applied automatically during purchase processing.
• Per-campaign global property overrides, which let you schedule Limited Time Game Modes, such as Double XP Weekends, and Seasonal Modes (eg, Halloween, Happy Holidays, Boxing Week) that you set up in the client.
• Client support - a new Campaign client API (GetMyCampaigns) lets games read a player's eligible campaigns; brainBot can also help you create and refresh campaigns.

LiveOps Campaigns are an Enterprise Feature, available on Business/Business+ plans and higher.

Choose the type of campaign

Target the players you want, now with compound segments

Define your Scenarios and audience allocation

Use Global Property overrides to activate Limited Time Game modes in your client

LiveOps Campaigns are in [beta] while we continue working on the companion analytics features. Stay tuned!

Group Tournaments

We’re pleased to announce that brainCloud's tournament system now supports group-based competition. Tournaments and division sets can be configured with a GROUP entry type, allowing clans, guilds, and teams to compete against each other as single entities — each group enrolls in a tournament, posts shared scores, and is ranked on a group leaderboard. 

This includes support for division sets, where groups are automatically bucketed into division instances of a fixed size (for example, 100 groups per division instance) and compete only against other groups in their division. 

The Design Portal has been updated to support group entry types on tournament and division set configurations, including filtering configs by entry type. 

Note that group tournaments handle rewards via a post-processing script rather than brainCloud's built-in payout rules, so entry fees, payout rules, and tournament notifications do not apply to group-type tournaments.

60-Day Retention Analytics [ENTERPRISE]

Customers on Business/Business+ and above plans will see that our retention analytics now reach back a full 60 days - which means you can see a full month’s worth of D30 data! A new smart mini-card surfaces the extended window and the analytics-history status.
As part of this work, non-Enterprise customers will see a new D14 card, which is more useful than the previously single-point D30 card.

Segment Enhancements

The Segment Builder now supports nested AND/OR condition groups.  This helps your team effectively focus segments on the exact users they want to find. As always, Promotions can be made eligible to specific Segments.

Segments also now support Segment Codes - short, human-readable, permanent identifiers (e.g., new-players, usa_testers) that can be used in place of the numeric legacy ID when referencing a segment across Promotions, Notification Jobs, Campaigns, and Cloud Code.

But that’s not all, Segments can now be preserved during deployment. This allows you to create and edit your Segments in your Production app directly without worrying about them being overwritten.

Note that the APIs (client, S2S, and Cloud Code) now accept either segment IDs or segment codes - see API Changes for the full surface. We recommend moving to codes; Cloud Code can be locked to codes only via the new acceptLegacySegmentIds compatibility flag.

Godot GDScript!

We were one of the first backends to support Godot with our C#-based libraries – and now we’re happy to complete that support with our new GDScript-based libraries!

With our new GDScript plugin, you get the full brainCloud backend experience right in the language you already love:

• User authentication & profiles
• Cloud save & player data
• Leaderboards & matchmaking
• In-app purchases & economy
• Real-time multiplayer
• Push notifications & more

And to help you hit the ground running, we've built the Godot version of our Cursor Party demo app: a ready-to-run project showing GDScript + brainCloud in action. Grab it from the Godot Asset Library and start building today. 

Get the plugin: https://godotengine.org/asset-library/asset/5196

GD Script Cursor Party Demo: https://github.com/getbraincloud/examples-godot/tree/master/RelayTestApp-GDScript

Multiplayer & Hosting

i3D.net FlexMetal

Building on our i3D.net Orchestrator integration, brainCloud 6.0 adds support for i3D FlexMetal hosting, providing developers with access to bare-metal servers for brainCloud applications.

Our FlexMetal integration integrates deeply with brainCloud, supporting:

• Lobby Matchmaking
• Room Servers ← provide your own container image
• Relay Servers ← use brainCloud Relay Servers and RelayComms API
• Server Monitor ← monitors the launched FlexMetal servers.

More Lobby control

We’ve been gradually enhancing our Lobby APIs to support different player scenarios. 

The following enhancements are present in this release:

•  New CreateLobbyWithConfig() calls support overriding the team objects of an individual lobby. Useful if a player wants to limit their match to a different # of players than the lobby default
• Players can join during the starting phase of a match when Join-In-Progress is enabled

More Room Server control

This API allows devs to have greater control over the images used for their Room Servers:

• New call, SysUpdateRoomServerImage(), to update a Room Server's Docker image.

Marketplace

We have also been working on improving our Marketplace services. In addition to the new Lobby Campaign system, you’ll notice the following improvements.

• Archiving Products & Promotions

  • Deleting products and promotions has always been an issue, as you lose valuable revenue data. But keeping the old, no-longer-available Products and Promotions around makes them difficult to manage.
  • Our solution? Archive them! Now you can Archive Cash Products and Promotions – and they will disappear from your lists - but they are still there in case your reports refer to them [and customers restore purchases related to them]

• Auto-promotions can now target existing segment members

  • A new "Applicable Members" option lets a promotion apply to both existing and new members in a segment (previously, only new entrants).

• Per-platform bonus rewards 

  • Now, customers on Apple can get an iOS-branded decoration, while the Google Play Store players get an Android-specific decoration. You can also configure bonus currency payouts per store.  

Platform Support

Steam

• Updated Steam authentication - requires new Steam Identity setting on the Steam tab of App > Design > Core App Info > Application IDs page. New compatibility flag.
• Subscription (recurring billing) support - new and now supported
• Default-currency support ← set the default currency on the Steam tab of the App > Design > Core App Info > Application IDs page.

VisionOs

• Apple's visionOS is now a first-class platform on both server and portal, with clearer product-key labeling for visionOS keys.

PlayStation Network

• Updated Network Architecture support

App Alerts

App Alerts is the name we use for the warnings we show in the Alerts section of the App Dashboard.

Up until now, you had to log in to brainCloud to see them.

brainCloud 6 adds the ability to email these alerts to you!

Just go to the App > Design > Core App Info > Alerts page to add your email - or better yet, add the email for a team distribution list or a Slack channel.

Auto-Reconnect

We are sure this little feature will have some fans.

Enabling the new auto-reconnect in your client reduces the pain of ensuring the brainCloud session is still alive - especially useful as the user moves in and out of the app during their day.

Just call EnableAutoReconnect(true) after initial app start-up and authentication.

Portal Changes

We continue to polish the Portal with every release. The following areas of the portal got some extra love for this release:

App Management

The Team > Manage > Apps screen now provides additional context about your app’s consumption under its current plan. The bars will tell you when it makes sense to upgrade to the next highest plan. 

As you can see from the image:

• The development apps are well within their DAU and Total User limits
• The production app should be upgraded to a higher-level plan!

And if/when you choose to upgrade your plan, you’ll find more information to help you make the right decision.

Deployments

We have reworked the App > Admin > Deployment (and Import/Export) screens to be more instructive about which data will be migrated and when to use the Preserve/Exclusion options.

And the deployment screen will now remember the most recent deployment options you used, easing the drudgery of re-choosing the correct options for your development process each time.

There is even a new Item Catalog deployment tab that deploys only the Item Catalog data.

LiveOps Section

We’ve reorganized our key LiveOps systems underneath a new sub-menu. So now you will find:

• LiveOps Campaigns
• Promotions - both Automated & Scheduled
• Redemption Codes

All under the new App > Design > LiveOps section of the App menu.

Personalized Pricing

We have enhanced the Personalized Pricing page to support LiveOps campaigns.

So this is now the key screen to use when debugging the impact of Promotions and LiveOps Campaigns on the offers your end users experience.

Recent Errors

We have added some great improvements to the App > Global > Logs > Recent Errors screen.

These include:

• Improved Filter controls
• Recent Filters list - with the ability to pin favorites
• Exports! Export up to 10K lines of your current filter

Plus, we’ve made the screen prettier, too!

Note that these same enhancements also made it to the User > Summary > Recent Errors screen!

There were also changes to the following screens:

• App > Design > AI - new menu housing brainBot and AI settings.
• App > Design > Admin Tools > Deployment - redesigned for clarity, with separate Complete and Item Catalog deploys and improved dependency precondition checking.
• App > Design > Admin Tools > Configuration Data - reworked into separate Import and Export tabs, matching the new Deployment layout.
• App > Design > Cloud Code > Script Editor - improved syncing of changes (by other team members/tools)
• App > Design > Cloud Data > Global Properties - new Markdown property type, isSecret support, and category filtering when selecting properties.
• App > Design > Cloud Data > Segments - Segment Code field with guidance, AND/OR condition groups, and searchable dropdowns.
• App > Design > Integrations - new i3D FlexMetal integration.
• App > Design > LiveOps > Campaigns - the new campaigns experience, including the creation wizard.
• App > Design > Marketplace > Cash Products - type chips, search/filtering, archived-state treatment, and a refreshed edit dialog.
• App > Design > Marketplace > Promotions - archive/unarchive, status chips, and the new "applicable members" auto-promotion option.
• App > Reports > Analytics > Retention - 60-Day Retention minicard (Enterprise) and the D14 default card.
• App > Reports > Usage - AI usage on the API Usage and Monthly Summary screens; improved bulk-operations display.
• Team > Setup > Team Info / Billing - billing moved to its own page, redesigned team info, expanded Fusebill details, and complimentary-plan display across billing tabs.

API Changes

The following changes/additions affect the brainCloud API:

• AppStore

  • GetEligiblePromotions() - now includes eligible LiveOps campaigns for the user (with segment codes where applicable).

• Authentication

  • AuthenticateSteam() - updated to newer, non-deprecated Steam APIs. Note that there is a compatibility flag to preserve compatibility with existing apps.
  • AuthenticateGameCenter() - new API with improved security. Note that there is a compatibility flag to preserve compatibility with existing apps.

• Campaign - new service for LiveOps Campaigns

  • GetMyCampaigns() - returns the calling user's eligible LiveOps campaigns
  • SysTriggerCampaignForUser(), SysRemoveCampaignForUser(), and SysRemoveAllCampaignsForUser() - used for triggering / removing campaigns for test users 
• Client
  • EnableAutoReconnect() - enables the new auto-reconnect feature

• Lobby 

  • new CreateLobbyWithConfig() and CreateLobbyWithConfigAndPingData() calls that take a configOverrides (JSON) object that can be used to override certain settings of the lobby for this particular match
  • new join reason codes LOBBY_TEAM_FULL (40612) and TOO_MANY_USERS_FOR_LOBBY_TYPE (40624).

• Segments 

  • segment-targeting APIs now accept either a numeric segment ID or a segment code. Behavior is unchanged for existing integrations; codes are recommended. Cloud Code can be locked to codes via the acceptLegacySegmentIds compatibility flag.

    • Push Notification (Cloud Code & S2S) - send/schedule-to-segments calls such as sendRichToSegments, sendRawToSegments, sendNormalizedToSegments, and scheduleRich/Raw/NormalizedPushNotifications.
    • Script (Cloud Code & S2S) - runBatchUserScriptForSegments and the scheduleBatchUserScript...ForSegments variants.
    • Segment config (design / Builder API) - read / create / update / delete accept a segmentCode in place of segmentConfigId.
    • Promotions - support segment codes (segment-code matching on player refresh).

• Tournament

  • New Tournament service APIs for group play:

    • JoinGroupTournament() / LeaveGroupTournament() — enroll or withdraw a group from a tournament on a group leaderboard
    • GetGroupTournamentStatus() — retrieve the tournament timetable, configs, and the group's enrollment status
    • PostGroupTournamentScore() / PostGroupTournamentScoreWithResults() — post a score on the group's behalf, optionally returning the surrounding leaderboard results
    • JoinGroupDivision() / LeaveGroupDivisionInstance() — enroll a group into a division set (brainCloud assigns it to a division instance) or remove it
    • GetGroupDivisionInfo() / GetGroupDivisions() — query division set info for a group and list the group's active, pending, and completed divisions
    • SysGetGroupDivisions(), SysJoinGroupTournament(), SysLeaveGroupTournament(), SysJoinGroupDivision(), SysLeaveGroupDivisionInstance() — cloud-code system variants for managing tournament/division membership without membership checks

• PlayerState

  • New calls to allow programmatically resetting the sessions for a player; optional concurrent-session control/session locking: SysInvalidateAllButCurrentSession(), SysInvalidateAllSessions(), SysInvalidateAllSessionsForUser(), SysInvalidateAllSessionsForUserExcept(), SysInvalidateCurrentSession(), SysInvalidateSessionForUser()
  • Renamed UpdateName() → UpdateUserName() in select client libs that were out-of-sync.

• RoomServer (S2S)

  • LAUNCH_SERVER renamed to SYS_LAUNCH_SERVER, and its scriptId parameter is now scriptName for easier use.

Libraries and Examples

Client Libraries

All Libraries

• Group Tournaments & Group Divisions APIs - full set on the Tournament service (join/leave/post-score for group tournaments; get/join/leave for group divisions).
• Campaign service - new GetMyCampaigns() call for LiveOps Campaigns.
• Lobby config & ping - CreateLobbyWithConfig() / CreateLobbyWithConfigAndPingData() and a getPingDataSnapshot() accessor.
• RTT auto-reconnect - enableAutoReconnect() plus register/deregister callbacks, so long-lived sessions transparently re-authenticate after a drop (formerly "long session").
• Request compression - compressIfLarger threshold check.
• Refreshed reason codes, service names/operations, and 2026 copyright headers.

Unity, C#, and Godot

• UDP Relay handshake stabilized across Unity, Godot, and Xamarin (fixes silent UDP connect failures on Godot and under network latency on Unity/Xamarin).
• Game Center authentication updated for the new server call.
• Deprecated functions marked obsolete and removed; DLLs now built without deprecated functions.
• New.unitypackage build/release pipeline.

C++

• getPingDataSnapshot() on the Lobby service (thread-safe), returning a region-to-ping map; more performant ping handling.
• cURL loader reworked to reuse the curl handle/connections (Linux connection-cleanup fix).

Java & Android

• Campaign service added to the Android wrapper; createLobbyWithConfig / ...AndPingData; auto-reconnect re-authentication callback; compressIfLarger.

JavaScript

• Group Tournament APIs, getMyCampaigns, ping-data access, and auto-reconnect (enableAutoReconnect + callbacks); latest API additions and reason codes.

Objective-C

• Group Tournament APIs.

• SAMKeychain Dependency integrated into the client to support VisionOS

  • You may need to update code references

    • #import "SAMKeychain/SAMKeychain.h" → #import

  • You may need to add Build Settings to locate the required new headers.

    • $(PODS_ROOT)/BrainCloudCpp/Include/brainCloud/internal/Apple

• Minimum OS deployment targets were raised or added

  • iOS 12.0 → 15.0
  • MacOS 10.13 → 13.0
  • tvOS 12.0 → 15.0
  • watchOS 4.0 → 8.0
  • visionOS 1.0 * New

Unreal

• "Long session" renamed to auto-reconnect; fixes for UE 5.6+ on macOS.

Roblox BETA

• Designed to be intuitive, developer‑friendly, and aligned with Roblox's client‑server model. 

  • Requires HTTP Service and Studio API Services. 
  • Real‑time socket and relay features are limited by Roblox platform constraints.

• Now supports all of: 

  • Authentication tied to Roblox UserId 
  • Tournaments, leaderboards, achievements 
  • Cloud player data storage 
  • Virtual economy and item systems 
  • Cloud Code for secure server logic 
  • Messaging, notifications, and in‑game mail 
  • Analytics for behavior, retention, and monetization
• Get the new brainCloud Roblox Plugin for your Roblox development environment here: https://create.roblox.com/store/asset/132685604407597/brainCloud

S2S Libraries

• Global File upload via S2S - SysUploadStream / Global File Service added to the C++, Java, C#/.NET, and Node S2S libraries.
• C# S2S - RTT comms / WebSocket support refactor.
• Unreal S2S - structural refactor, secret obfuscation in logs (on by default), and a request builder with operation/param/service-name constants.
• Node S2S - Pre-Launch Ready support (server accepts pre-launch ready).

Example / Demo Libraries

•  Cursor Party (Relay Test App,RTA) - a unified cross-platform refactor across C++, C#, Java, JavaScript, Unity, and Unreal, now displaying Ping Region data in-game; Unity adds a 4-player Play Mode scenario, and colors are driven from a global property. Updated display with cloud-driven colors, splat effects, and a new icon. Updated Auto Ping Regions across lobby types within C++.
• BCFishnet (Unity) - lobby pin support; C# S2S RTT support example.
• Pre-Launch Ready (PRL) support and documentation across the JavaScript/Node demos.
• Marketplace - Focused on Marketplace features, demonstrating items, bundles, cash products (IAPs) and subscriptions, as well as user experience and levels, status effects, etc.

Documentation and Tutorials

• All API additions and changes are documented at docs.braincloudservers.com.
• In addition, we have now added both Roblox and GDScript code samples for all API methods to the docs.
• The Cloud Code scripting guide is updated to cover segment-code usage and the per-app compatibility flag. 

Updated Terms of Service

Alongside the platform launch, we've updated our legal and policy documents to reflect what brainCloud 6 actually does. These updates take effect Monday, June 22, 2026.

Everything lives in our new Trust Center:
https://getbraincloud.com/trust/ 

What's changing

Terms of Service - Updated to cover AI services, beta features, and a cleaner structure overall. The core commercial terms (governing law, liability, payment) are consistent with what you're used to.

Privacy Policy - Updated to reflect AI data handling and modernized privacy rights. The key commitment: brainCloud will never use your data or your users' data to train AI models.

Data Processing Agreement - Updated with formal schedules and the same no-training commitment for AI. If you've signed a separate DPA with us, the new version supersedes it.

Cookie Policy - Broadened from EU-only to global.

Service Level Agreement, Acceptable Use Policy, and Subprocessor List - Updated to reflect brainCloud 6 and current operational practices.

New documents -  We've also added a Security Overview, Vulnerability Disclosure Policy, Support Agreement, and Deployment Responsibility Matrix for customers who need them for procurement or compliance purposes.

What you need to do

Nothing urgent. Continuing to use brainCloud after June 23 constitutes acceptance of the updated terms, consistent with our existing Terms of Service. If you have questions about any of the changes — particularly the DPA if you're subject to GDPR or similar regulations — feel free to reach out via the email address listed in the Trust Center.

Executive Summary

brainCloud 6 is bringing a bunch of improvements to segments. As part of those improvements, we are replacing the existing Segment IDs, which are auto-generated numeric IDs, with Segment Codes, which are short alphanumeric codes that you pick.  (See later sections for rationale)

The important thing to note is that you have until the end of the day on Friday, June 5th, to set these codes - after which the system will auto-generate the codes for you! [And codes cannot be changed once set].

Tips when setting the codes:

• Codes are lowercase and limited to 12 alphanumeric characters. Letters, numbers, hyphens, and underscores allowed. No spaces.
• Try to pick meaningful names: “newbies”, “lifers”, “payers”, etc.
• Ensure that the codes in the Dev and Prod versions of your apps match up! That’s the whole point of this change - is to improve segment deployments!

Background

Segments in brainCloud have long-used Segment IDs, which are auto-generated numeric IDs. The first segment created is 1, the second is 2, and so on.

This simplistic system works fine - until you start really getting into segments - and start creating them in the prod instance of your app separately from the dev instance of your app.  Even if you remember and go back to the dev instance of your app to backfill them, you’ll often find that the segment IDs in the two app instances don’t match up!

So, for instance, your “Players” segment for players who have spent more than $0 – might have a segment ID of 2 in the live version of your app - but 3 in the dev version of your app!  

This wreaks havoc if you deploy from Dev → Prod, as the Dev segments will overwrite the Prod segments - and it takes a day for the segment membership to catch up!   

The Solution - Segment Codes

Segment Codes are our solution to this problem. They are short 12-character codes that uniquely identify a segment. Because they are manually set, it is easy to keep them in sync between Dev and Prod.

This makes for better code as well - triggering the push notification job to a particular segment is easier to understand with a meaningful Segment Code instead of an arbitrary Segment ID.

API Impact

Note that from an API perspective, Segment IDs will continue to work. That said, we are extending all API calls to work with Segment Codes as well, and we encourage everyone to move to that mechanism.

Deployments

Finally, we are adding a new option to exclude Segments from deployment. Segments are more of a LiveOps domain element than an app design concern, so we are extending the Deployment system to allow Segments to be excluded from Deployment in the same way that Cash Products, Promotions, etc. can be now.

[Note - start time has been updated from 8pm -> 6:30pm Eastern.]

brainCloud BaaS will be upgraded to MongoDB 8.0 on Monday, July 7th, starting at 6:30 p.m. Eastern. This rolling upgrade may take up to 3 hours to complete. All API and Portal services will be fully available during the upgrade; the portal will NOT be disabled.

[Full disclosure: It will take longer than usual because we are first upgrading to MongoDB 7.0, and then immediately upgrading to MongoDB 8.0.]

Note that all brainCloud Private Instances will be upgraded in the weeks before the end of July 2025.

Compatibility

brainCloud 5.7 has been tested to be fully compatible with MongoDB 8.0.

Important Change (READ THIS!)

MongoDB 8.0 contains an Important Change that brainCloud developers must be aware of.

Starting in MongoDB 8.0, comparisons to null in equality match expressions don't match undefined values.

Consider the following table:

In MongoDB 6, a query for { "name": null } would return all 4 records, as per these conditions:

• The name field is null (_id: 1)
• The name field is undefined or contains an undefined array element (_id: 2 and _id: 3)
• The name field does not exist (_id: 4)

But in MongoDB 8, the query for { "name": null } only returns 2 of the records:

• The name field is null or contains a null array element (_id: 1)
• The name field does not exist (_id: 4)

Note that this change in query behaviour also affects $eq, $in, and $lookup operations.

For full details on MongoDB compatibility changes:

• MongoDB 7 - https://www.mongodb.com/docs/manual/release-notes/7.0-compatibility/
• MongoDB 8 - https://www.mongodb.com/docs/manual/release-notes/8.0-compatibility/

brainCloud Customer Impact

This change only affects brainCloud's list and paging-style calls (which accept custom query JSON) - and ONLY apply if the JSON data itself somehow had undefined values -- which would be pretty unusual.

The affected calls include:

• Custom Entity - GetEntityPage(), SysGetEntityPage()
• Entity - GetList(), GetListCount(), GetPage()
• Global Entity - GetList(), GetListCount(), GetPage(), GetSystemEntityList() GetSystemEntityListCount(), GetSystemEntityPage()
• Group - ListGroupsPage(), GetRandomGroupsMatching(), ReadGroupEntitiesPage(), SysGetRandomGroupsMatching(), SysListGroupsPage(), SysReadGroupEntitiesPage()
• Item Catalog - GetCatalogItemsPage(), SysGetCatalogItemsPage()
• Leaderboard - SysGetLeaderboardConfigsPage()
• Messaging - GetMessagesPage(), SysGetMessagesPage()
• RedemptionCode - SysGetCodeTypePage()
• User - SysGetPage()
• User Items - GetUserItemsPage()

So - this is ONLY an issue if:

• Your app has "undefined" values in its JSON entities
• AND it is querying on those fields with "undefined" values
• AND it is specifically querying those fields for "null" and expects "undefined" values to be included with the query results.

Take action!

If you do feel that this issue may affect your app, reach out to us in support with the following information:

• appId
• category of entity affected (eg, User, Global, Custom, etc).
• entityType field
• field name

We may be able to help you prepare the data so that "undefined" fields are replaced with "null" values to ensure that queries continue to work.

brainCloud 5.5 has something for everyone: Retention Analytics, support for Dart and Flutter, Optimized Group Leaderboards, App Alerts, an Improved Matchmaking Monitor, Improved Security, and more!

Compatibility Notes

We work hard to preserve stability and backward compatibility for existing apps.

Developers should be aware of the following changes:

• Cancelling Find Requests: the LobbyService’s CancelFindRequest() method now requires an entryId be passed into it. This change was technically introduced in 5.4.X, but we note it here for completeness.
• Relay Servers: Significant improvements have been made to how the Relay Servers handle large matches (i.e., matches with more than 30 players). These improvements involve reusing abandoned slot IDs, a behavior change that may impact certain games. Therefore, we made the new software available as the “V3” Relay Server protocol. The protocol APIs themselves have not changed. Most games that work with V2 should work unchanged with V3.
• Group Leaderboards: 5.5 now stores Group Leaderboards in collections separate from regular Player Leaderboards. The older combined storage is still supported and is the default for existing apps. The new compatibility flag controls this behavior: “[x] Store user and group leaderboard scores in the same collection (slower).” This flag is enabled by default for existing apps and disabled for new apps. Changing this value for an existing app will make old group scores (written to the combined collection) inaccessible.

Release Highlights

Retention Analytics

Retention is a metric that indicates how effectively your app engages new users and entices them to return. It is measured over time and represents the percentage of users who return after 1 day, 7 days, etc.  

There are two common variations of retention - Classic Retention and Rolling Retention.

Classic Retention measures the percentage of users who return on a specific day (i.e., D+7 = day 7 - which is 7 days after their account was created). 

Rolling Retention measures the percentage of users who return on that day or any day thereafter.  (i.e., a user who returns on day 7 is also deemed “retained” on all previous days).  

Rolling Retention numbers will always be higher - and will reliably decrease over time – while Classic Retention stats will bump up and down (especially during the first week) - as some users may return on day 3 that didn’t return on day 2, etc.

Classic Retention helps measure the day-to-day engagement for the first week of your app - while Rolling Retention allows for greater generalizations about your app (i.e., 20% of players are still active after 1 week).

brainCloud’s new Retention Analytics screen displays both Rolling Retention and Classic Retention.

As you can see in the image below, the screen is quite dynamic and offers many ways to view this critical metric. 

Note that apps must be LIVE to generate retention analytics. These stats do not make sense for apps under development - so we do not generate them for Dev and Dev+ apps.

Related: Another metric is Churn - which is the percentage of players who stop using your app within a specific timeframe. brainCloud doesn't display it - but it is easy to calculate. Churn is the inverse of Rolling Retention. If your D+7 Rolling Retention is 20%, then the Churn after 1 week is 80%.

App Alerts

brainCloud 5.5 includes our new App Alerts feature. This feature will perform various checks on the health of your app - and display important information regarding its findings in your App Dashboard.

The initial alerts that can be triggered include:

• Apple Push Notifications - Reminders for devs to update their certs
• API Errors - Alerts if error levels are high or rising
• Logging - Alerts if the app is generating excessive logs
• Compatibility flags - Reminder to evaluate and disable unnecessary compatibility flags
• MFA Enforcement - Reminder to enable the new MFA Enforcement feature for live apps

We will continue to evolve and expand upon this feature in coming releases!

Dart and Flutter Support

Dart is a client-optimized language for developing fast apps on any platform. Developed by Google, Dart is similar to JavaScript but is simpler, faster, and more user-friendly.  When paired with the Flutter UI framework - it is a highly productive foundation for building cross-platform applications.

brainCloud 5.5 includes our new Dart client library, which supports all of brainCloud's features and services - including RTT and Relay Comms.  You can find the source for the library on GitHub - and the package itself on pub.dev, the official package repository for Dart and Flutter apps.

Security Improvements

Security has always been a key concern for the brainCloud Platform - and this release makes two key platform improvements in this area.

Brute Force Protection for User Accounts

A brute force attack is a hacking method that uses trial and error (often in a sequential organized fashion) to crack passwords or login credentials.  

brainCloud’s new Brute Force Attack Protection feature thwarts these attacks by blocking the ability to login to an end-user account after an escalating number of bad attempts – similar to how your smartphone makes you wait between login attempts when you get the password wrong.

The feature is enabled and configured on the new App > Design > Security > User screen.

It works like this:

• brainCloud counts the number of bad login attempts in a row for end-user (e.g., player) accounts. Bad logins increment the count. Good logins reset the count to zero.
• If the # of bad attempts exceeds one of the escalating thresholds, the account becomes “blocked,” during which both good and bad login attempts are rejected… ← this is key - if we allow “good” login attempts while blocked, we won’t stop the attack!
• Note that while the account is blocked - the block time does not extend with each new login attempt - if we did, the lock time would quickly escalate to an unworkable value. So login attempts while blocked are essentially ignored - though we do increment the bad login count appropriately. We do NOT extend the “blocked until” time while the account is blocked.
• Eventually, the “block” will timeout - after which - the next login attempt will be considered. If it’s good - the user will log in - and the bad login count will be cleared to 0.  If the login attempt is bad, the count will increment - and become “blocked” again for a duration appropriate to the new threshold level.
• If Sendgrid integration is enabled - the user can enable emails that will be sent to the user each time the account becomes “blocked” due to this feature.

Important - during the period that logins are “blocked” - both bad and good logins are rejected. Note that anonymous reconnects are by default NOT blocked - so users already logged into a device are not inconvenienced by the attacker’s activity.

Unblocking End-user accounts

The User Summary page has been enhanced to show additional information regarding bad login attempts. See the Portal Updates section for more details.

What about Brute Force Protection for Portal Accounts? 
brainCloud already provides this sort of protection for Portal accounts. And the new Team MFA Enforcement feature (below) makes these accounts even more secure! 

Team MFA Enforcement

This feature adds additional protection to a developer’s Team Member (i.e., Portal) Accounts. 

brainCloud has long supported MFA authentication for Portal Accounts - but now Team Administrators can make MFA mandatory for all Team Members. This is done via the Team > Setup > Team Info screen.

Once enabled, only Portal Users using MFA will be allowed to log into the team.  

Team members not using MFA can configure it from the Team Selection screen by clicking the Enable MFA or the [Edit Security] button.

Note that for Private Licensees, SSO-based Portal Users are treated as MFA-enabled - as it is assumed that MFA is provided by their SSO solution.

Additional Improvements

Release 5.5 includes a ton of other improvements as well. These include:

• API Improvements

  • New APIs have been added to the AppStore, Authentication, and Lobby services. See the API Changes section for more details.

• [Refresh] App Metrics

  • App metrics are daily processes that aggregate and calculate various statistics about your app - such as API Usage, sales aggregation, retention data, etc.
  • In some rare circumstances - the calculation of those metrics may be interrupted.
  • To re-trigger the calculation of the metrics - navigate to App > Design > Admin Tools > Cache and click [ Refresh Metrics ]

• Client-Server Protocol

  • We have improved our protocol handling so that client retry attempts are now properly compressed (when applicable)

• [Optimized] Group Leaderboards

  • Before 5.5 brainCloud, player- and group-based leaderboards were stored in the same collections. This is not optimal - especially when dealing with large [sharded] leaderboards. brainCloud now stores player-based leaderboards and group-based leaderboards separately.  
  • A new compatibility flag controls this behavior. When enabled, the flag preserves the old behavior. The flag is enabled by default for existing apps and disabled for new apps.

• Hosted Servers

  • A new "Retrieve Logs" option was added, which determines whether the logs from successful room/relay server sessions will be retrieved. By default logs will only be retrieved if the container exited with a non-zero result.

• Matchmaking Monitor

  • The Matchmaking Monitor has been enhanced to show stats for how fast players are launched into actual matches.  ← Before the stats stopped at being added to a Lobby

• Portal SSO and Builder API

  • The Builder API has been enhanced to support dynamic authentication as an OAuth SSO Provider
  • This allows Private and Platform Licensees to build custom applications that use brainCloud’s Portal Accounts for authentication - and access brainCloud’s Builder API via new dynamic [and temporary] API keys
  • Note that this SSO Provider is for portal accounts only - not the end-user accounts of brainCloud apps [that is a future feature under consideration]

• S2S IP Security for Room and Relay Servers

  • brainCloud can now dynamically restrict the S2S interfaces associated with Room and Relay servers to the IP addresses of the currently running servers.
  • To enable this feature - go to App > Design > Servers > My Servers, choose the appropriate server type, and enable IP Security.  

• Relay Server Improvements

  • Improvements for when dealing with larger player counts
  • Ability to restrict relay comms to less than 40 players (now defaults to max of 32 for webgl compatibility)
  • Improved disconnect handling
  • Note that the above improvements are all made available via the “V3” version of the Relay Server. The behavioural changes are very subtle and shouldn’t impact the great majority of apps. We highly recommend that devs using “V2” upgrade to “V3” in their test apps (no API changes) and upgrade production when convenient.

Portal Updates

We continue to rapidly evolve the Design Portal.

Team Menu

The flag to enable Team MFA Enforcement has been added to the Team > Setup > Team Info screen.

App Menu

App Dashboard

The new App Alerts section is front and center on the App Dashboard.

We have also added your Client Library version to the App Profile section.

Cloud Code (rendered view)

We’ve added an option to view the rendered version of a cloud code script.  If the [x] Show Rendered option is enabled, the editor shows a read-only view of the script with all included scripts shown inline. This view matches the version of the script that brainCloud keeps cached for runtime execution.

Security

This release consolidates App-related Security sections under App > Design > Security.  

You will find the old settings from App > Design > Core App Info > Security here, as well as the new Brute-Force Protection settings. 

Matchmaking Monitor

The Matchmaking Monitor has been enhanced with a new screen that shows a summary of matchmaking activity across all lobby types.

Click on any row to navigate to the detailed monitoring charts for that Lobby Type.

The details screen has been enhanced to show how long it takes for matches to launch on servers.

The time displayed includes the time it takes to spin up a container (on-demand) - as well as the time to cold-launch a node (server) for the container to run upon (if applicable).

Blocked Users

The User Browser (preview blade) and User Summary screens now show information about Bad Login Attempts and whether a user has been blocked. There are also controls that allow a Team Member to [UNBLOCK] the user and/or [Reset] the bad login attempt count.

Retention Analytics

The new Retention Analytics screen can be found at App > Reports > Analytics > Retention.

Previous day usage

In addition to Today and Yesterday - the API Usage and API Errors screens now include a tab labeled “Previous,” - which displays the stats for the day before yesterday.

API Changes

The following changes and additions have been made to the brainCloud API:

• AppStore Service

  • New API for rewarding products (without a corresponding purchase)
  • New API for recording a purchase (for cases where purchase is handled by custom client code).

• Authentication Service

  • Password reset calls are now accessible from cloud code
  • New GetServerVersion() call available to retrieve the brainCloud server version before authenticating.  This is useful for our example apps.

• Bridge (cloud-code only)

  • New DeleteSessionCacheObject() method - useful if you only need a session cache object temporarily - like when passing information from a pre- to post-hook script.

• Event Service

  • New SendEventToProfiles() method allows for sending the same event to multiple users

• Friend Service

  • New GetProfileInfoForCredentialIfExists() method is the same as GetProfileInfoForCredential() - but skips writing the log entry if the credential doesn’t exist

• Group Service

  • The UpdateGroupAcl() and UpdateGroupEntityAcl() methods are now available from the client libs; previously, they were cloud-code only.

• Identity Service

  • The GetIdentityStatus() method is now available from the client libs

• Leaderboard Service

  • The PostScoreToDynamicGroupLeaderboardUsingConfig() method is now available from the client libs. This method should be used instead of PostScoreToDynamicGroupLeaderboardUTC() and PostScoreToDynamicGroupLeaderboardDaysUTC().

• Lobby Service

  • The CancelFindRequest() method now requires an entryId as a parameter. The entryId is included in the response from the various Find Lobby API calls.
  • New SYS APIs: SysCreateLobby(), SysCreateLobbyWithPingData(), SysGetLobbyData(), SysAddMember(), SysAddMemberWithPingData(), SysRemoveMember(), SysUpdateSettings()

• Mail Service

  • New SendAdvancedEmailByAddresses() method for sending a single email with multiple addresses in the “to:” list.

• PlaybackStream Service

  • The ProtectStreamUntil() method has been added to the client libs. This allows a developer to keep a playback stream around for longer than the default – which is currently 150 days in our Public BaaS.  Extending specific streams is helpful for games that use the streams for ghost replays - and want to keep “featured replays” around longer.

• [New!] Report Service

  • SysGetLatestReport() - returns the data from the latest generated report (of the specified type).
  • SysGetReportForStartDate() - returns the data from the specified report.

Libraries and Examples

Release window - Updated Client and S2S libraries are made available within two weeks of the launch of the updated server software. Updated examples are made available in the two weeks after the client lib updates.

Client Libraries

All Libraries

• All new and missing methods were added as described in the API Changes section.

braincloud-csharp (C#/Unity/Godot)

• Created overloaded FindLobby functions that do not require timeoutSecs parameter. Original functions have been deprecated.
• Improved country/region code retrieval for UWP with Windows.Globalization
• Improved error-handling for Relay Comms ordered packet IDs management
• Fixed issue with WebSocket in WebGL on iOS where the browser resets due to running out of memory

braincloud-unreal-plugin (Unreal)

• Implemented request/response compression

• RTT bug fixes/improvements

  • Fixed issue where the disconnect callback wasn't being triggered in a situation where RTT connection is lost from internet connection becoming unavailable (tested by not sending heartbeat messages)
  • Fixed issue where calling EnableRTT twice before a connection is established causes connection issues, the function is now safeguarded from double calls
  • Fixed issue where received RTT messages were incorrectly processing special characters / non-ASCII characters

braincloud-js (JavaScript)

• Fixed bug in attachAdvancedIdentity function

  • The conditional statement for optional externalAuthName was not checking for authenticationSubType correctly

braincloud-dart

• A brand new library with full support for all brainCloud APIs - including RTT and RelayComms

• The source can be found in the following github repos:

  • braincloud-dart - the core dart library. No flutter dependencies.
  • braincloud-dart-persistence - An add-in library that utilizes Flutter to implement the persistence required by the brainCloud wrapper. It is highly recommended that devs use this with the core library.

• The packages can be found on pub.dev at the following locations:

  • braincloud - the core library package
  • braincloud_data_persistence - (see description above)

S2S Libraries

No changes in this release.

Examples

All examples will be updated to use brainCloud 5.5 in the coming weeks (generally 2-4 weeks after release).

Documentation and Tutorials

BootCamp

• No changes

Documentation

• All the latest API additions and changes have been incorporated into our docs.

brainCloud 5.4.1 isn't a full release - but there have been enough tweaks and improvements to warrant a page describing them.

Features and Improvements

PlaybackStream Protect API

brainCloud 5.4 added Sys APIs for PlaybackStreams - to make them more convenient for use as ghost players, community members in hub worlds, etc.

A challenge, however, is that PlaybackStreams are automatically deleted 90 days after creation. This may not be desirable in all use cases.

To address this, we have added new APIs to "protect" a stream from automatic deletion for a number of days. This API can be called periodically to keep specific playback streams around in perpetuity...  (For example - a cloud code script could be written to run daily to protect the "featured" replays of the system for days into the future).

The new calls are ProtectStreamUntil() and SysProtectStreamUntil().

Apple Receipt Validation Improvements (and a new warning)

We have addressed a scenario where brainCloud was not validating the bundle id for old legacy-style receipts -- even if the bundle Id has been correctly entered on the App > Design > Core App Info > Application IDs page. This has been fixed.

That said - we remind devs that the Bundle ID field, although optional, does allow brainCloud to further validate that the receipt provided is from proper app. It is highly recommended that developers using Apple's AppStore for In-App Purchases fill in this value!

To encourage the use of the field, we have added a new warning for Apple purchases made without validating the bundle ID. The warning includes the bundle ID present in the used receipt.

The message looks like this:

Purchase security warning - iTunes bundle id should be set for greater security. Purchase with bundle id '' still processed.

You can search for these warnings using the following log filter:

• service: appStore
• operation: VERIFY_PURCHASE

We have added a new warning message to the system as a reminder to fill it in and as a confirmation of what bundle ID was currently used. Developers can use the warning to confirm what value should be entered on the page and look for fraudulent entries.

View Leaderboard and Group users in a separate tab

We have expanded our UI paradigm to allow viewing users in a separate browser tab - without otherwise losing the context of where the team member is in the Portal. 

For now we have added this feature to just the Leaderboard and Group screens - but we'll be adding more support in coming releases.

Miscellaneous fixes and improvements

Server fixes and improvements

• BCLOUD-7437 - Fixes to user rate limiting
• BCLOUD-8468 - Server request-response log - add incoming IP to ERROR MESSAGE instead of RESPONSE
• BCLOUD-8869 - Add support for existing filters to the export functionality
• BCLOUD-9262 - Performance improvement: now reading shard count at beginning of matchmaking run
• BCLOUD-9285 - Change to the "never" Global Entity expiry value to prevent issues in javascript
• BCLOUD-9315 - Added new PlaybackStream APIs: ProtectStreamUntil, SysProtectStreamUntil
• BCLOUD-9356 - Modified support for CANCEL_FIND_REQUEST to require an entryId to work; without it the call is a no-op
• BCLOUD-9357 - Increment user's failedRedemptionsTotal for each RedeemCode attempt after being locked out
• BCLOUD-9358 - Removing support for lobby entry queue v2 (everyone is on v3 now)
• BCLOUD-9378 - PortalX is loading uppercase email address and the Server is not automatically lowercasing it
• BCLOUD-9379 - Spelling mistake in Amazon IAP error message
• BCLOUD-9386 - Global Entities count on list screen including expired entities
• BCLOUD-9390 - Bug fix for treating a full team as a full lobby during lobby join
• BCLOUD-9393 - Builder API Create a cloud code script returned error
• BCLOUD-9398 - Builder API Team Level - Fix for out-of-date updatedAt value
• BCLOUD-9400 - Request/Response entry pairs not matching on sequenceId
• BCLOUD-9411 - Log all APP packetId-related errors as APP WARNING (not APP ERROR)
• BCLOUD-9425 - Added missing ENV variables for Edgegap servers
• BCLOUD-9447 - Compress cached last response if size is greater than maxLastResponseSizeBytes
• BCLOUD-9483 - Add pre-truncated request size to log when truncating it
• BCLOUD-9508 - Updated billing logging
• BCLOUD-9513 - Billing fixes… (had mistakenly treated some values at bytes instead of straight counts)
• BCLOUD-9528 - less strict on Lobby RemoveMember and UpdateSettings
• BCLOUD-9532 - optional (via brainCloud Property) logging of downloads
• BCLOUD-9542 - Validate range parameter in file servlet rather than passing on to CDN
• BCLOUD-9568 - Added ‘skip_telemetry’ parameter to Edgegap session creation
• BCLOUD-9581 - Added legacy sandbox receipt bundle id validation

Portal-X fixes and improvements

• BCLOUD-9336 - Fix issue in displaying brainCloud properties that have been overridden 
• BCLOUD-9361 - Hide RTT session chart on App Dashboard if RTT is not enabled
• BCLOUD-9365 - When creating global entities, the entity type should be selected by default
• BCLOUD-9370 - Fixed sort order in Server Monitor screen
• BCLOUD-9371 - Fixed percentage errors display in Script Usage panel
• BCLOUD-9377 - Added toast message failures during Export Configuration
• BCLOUD-9385 - Fixed Global Entities Export
• BCLOUD-9405 - Improvements to Universal Search SCREEN results presentation
• BCLOUD-9406 - Global Files - fixed issues around recovery folder
• BCLOUD-9407 - Updates and fixes to user request+response logs
• BCLOUD-9408 - Add the ability to view player/group in a new window/tab
• BCLOUD-9414 - Fix to display job results for all run states except Scheduled
• BCLOUD-9426 - Show “Loading…” for screen title text when loading screen data
• BCLOUD-9438 - Fixed issue with modal popup when no folders are present.
• BCLOUD-9439 - Fix issues in Global Files File Path & File Tree
• BCLOUD-9512 - Fixed Number (decimal) field issue in brainCloud Properties Dialogs
• BCLOUD-9582 - Addressed vulnerability CVE-2022-25927
• Plus - fixed formatting of available funds value in Team Billing info

brainCloud BaaS will be upgraded to MongoDB 6.0 on Wednesday, September 25th, starting at 8pm Eastern.  It is a rolling upgrade that may take up to 3 hours to complete.  All API and Portal services will be fully available during the upgrade. The Portal will NOT be disabled.

Note that all brainCloud Private Instances will be upgraded in the following weeks - before October 31st, 2024.

brainCloud 5.4 has been tested to be fully compatible with MongoDB 6.0.

That said, MongoDB 6.0 contains an Important Change that brainCloud developers must be aware of:

In MongoDB 6.0, $regex Find Queries No Longer Ignore Invalid Regex.  This means that while invalid $regex expressions were ignored in MongoDB 5.0 -- in MongoDB 6.0, the same query will return an error.

For example, in MongoDB 5.0, the following query, which includes an invalid regex option (i.e., "bad"), returns a successful database response with a document.

In MongoDB 6.0, that same query returns an error from the database - thus, brainCloud also returns an error.

This change only affects brainCloud's list and paging-style calls (which accept custom query JSON) - and ONLY apply if the developer-provided queries have invalid $regex or $options.  These calls include:

• Custom Entity - GetEntityPage(), SysGetEntityPage()
• Entity - GetList(), GetListCount(), GetPage()
• Global Entity - GetList(), GetListCount(), GetPage(), GetSystemEntityList() GetSystemEntityListCount(), GetSystemEntityPage()
• Group - ListGroupsPage(), GetRandomGroupsMatching(), ReadGroupEntitiesPage(), SysGetRandomGroupsMatching(), SysListGroupsPage(), SysReadGroupEntitiesPage()
• Item Catalog - GetCatalogItemsPage(), SysGetCatalogItemsPage()
• Leaderboard - SysGetLeaderboardConfigsPage()
• Messaging - GetMessagesPage(), SysGetMessagesPage()
• RedemptionCode - SysGetCodeTypePage()
• User - SysGetPage()
• User Items - GetUserItemsPage()

So - in summary:

• If your app isn't using $regex expressions in your query - you have nothing to worry about
• If your app is using VALID $regex expressions and valid $options - you have nothing to worry about
• If your app is using INVALID $regex expressions or $options - then brainCloud may now flag that error

A description of MongoDB 6.0 $regex and $options can be found here.

Feel free to reach out to brainCloud Support if you have questions.

brainCloud 5.4 is a massive update - and furthers our goals of advancing brainCloud’s support for Product Management, Customer Support, and Multiplayer Developers.

This release includes:

• New EdgeGap Multiplayer integration!
• New Matchmaking Monitor screen for visualizing the performance of Online Matchmaking.  Plus we’ve significantly improved the performance of matchmaking to boot!
• New Server Monitor screen for viewing hosted Room and Relay servers. We’ve added new launch progress events. And we have also added hosting capabilities for private deployments on Azure and Google Cloud!
• New Region, Language, and App Store analytics
• A bunch of API enhancements
• and much, much more! 

Plus - we bid farewell to our legacy portal! Long live Portal-X! 😀  

Notice - the new Region, Language, and App Store analytics screens will not be available until the nightly jobs can generate the required data. 

Compatibility Notes

Ensuring stability and backward compatibility for existing apps is a key priority. 

brainCloud 5.4 adds one new compatibility flag (enabled by default for existing apps) which allows devs to suppress the new server launch progress events.  This is a safety measure in case the client apps don’t automatically ignore them.

 Disable Room Server Launch Progress Messages

---

Release Highlights

EdgeGap Multiplayer

As you know, brainCloud provides everything you need right out of the box for easy-to-implement multiplayer. We’ve got flexible Online Matchmaking, Lobbies, Peer-to-peer and Dedicated-Server Examples, and built-in support for Room and Relay Servers that can be launched in regions all around the world.

But what if I told you that with hardly any changes to your multiplayer container - you can level up your multiplayer even further?  We’re talking lower latencies for players; faster cold starts; lower idle costs - and overall cost efficiency!

Too good to be true? Well - that’s what you get with our new EdgeGap Integration!

Just (1) set up an EdgeGap Account, (2) configure a server in brainCloud via the My Servers page (App > Design > Servers > My Servers), (3) link your lobbies to the new EdgeGap server type, and (4) modify your server code to tell EdgeGap when a session completes. That’s it - no client changes at all!

Pricing - requires a paid EdgeGap account. brainCloud does not add hosting fees on top of the EdgeGap charges. To compensate for matchmaking server usage, brainCloud adds 5 api counts per player matched to EdgeGap servers.

Matchmaking Monitor [Beta] & Sharded Matchmaking

brainCloud’s Online Matchmaking can be a tough process to visualize - until now!  

Our new Matchmaking Monitor screen (App > Global > Multiplayer > Matchmaking Monitor) provides real-time insights on matchmaking load and performance. Just select a lobby type and voila - the stats start streaming in.

And brainCloud’s matchmaking is now dynamically sharded - so extra CPU resources are brought online when you need them.

Note that this is a beta version of our Matchmaking Monitor - additional stats, better memory handling, and some more UI polish will be added in future releases.

Server Monitor [Beta*]

For those using brainCloud’s native Room and Relay Server Hosting - we’ve added a new Server Monitor screen (App > Global > Multiplayer > Server Monitor) to help visualize the running nodes and containers. Just select a server type and the screen will start updating.

Note that this is a beta version of our Server Monitor - there are plans to add CPU and Memory utilization metrics in the future.

Additional Improvements

brainCloud 5.4 includes a ton of other improvements as well:

• AppStore Transactions

  • We’ve added new cloud code-only methods for retrieving purchases recorded in brainCloud. Note that this API does not return data from the legacy transaction collections.

• Azure and GCloud Hosting

  • Private and Platform Licensees on Microsoft Azure and Google Cloud can now natively host Room and Relay Servers in those environments. Customers should contact brainCloud support to deploy the feature.

• Completed Divisions

  • Divisions no longer immediately disappear from getMyDivisions() once they have been claimed. They will now remain available in a COMPLETED state for as long as the division results are available.

• Dart & Flutter!

  • Our client team is hard at work creating a Dart version of the brainCloud library - suitable for use in Flutter and other apps.
  • It’s still early going - but feel free to check out the develop branch for an early look at things!

• IfExists Methods

  • Sometimes an error is okay - and there is no need to log it!
  • We have added new IfExists versions of several key methods (in the Leaderboard and Event services) to help keep your logs clean.

• Invisible Presence

  • Devs can now configure Presence so that users are initially invisible.  This is configured from the App > Design > Messaging > Presence screen.

• Remote DevTool

  • The Remote DevTool (remote to the brainCloud platform) allows developers to host Room Servers locally on their workstations for debugging purposes
  • Added a new and improved Debug Mode to better debug dedicated servers and hit breakpoints

• Replay System

  • brainCloud Playback Stream service is normally used for one-way multiplayer match replays - as demonstrated in the brainCloud Clashers demo.
  • This release adds new “Sys” and S2S-compatible APIs so that Playback Streams can be used by Custom Room Servers to directly enhance the gameplay experience. Think ghosts in racing games, crowds in hub worlds, etc.
  • In addition to the APIs - we’ve got a new example game, Invaders, that demonstrates the feature - and a great knowledge base article that describes how to make it work for your game!

• Server Launch Progress Messages

  • New events will be sent to all lobby members when starting hosted Room or Relay Servers
  • These events can be safely ignored – or can be used to communicate more information to clients as servers launch

• /servertime endpoint

  • A /servertime endpoint has been added to brainCloud, which returns the current server time in simple JSON format. 

• Status Effect Behaviour

  • Devs can now control, from the item catalog definition, whether status effects extend or replace the duration of the effect.   ← Initially introduced as a patch in 5.3

• WebHook Log Security

  • As a security feature, devs can now configure webhooks so that key parameters received are not recorded in the server logs

---

Portal Changes

We continue to rapidly evolve the new Portal. 

In addition to the new Matchmaking and Server Monitor screens (see above), 5.4 adds new Analytics, Usage, and Usability features!

Analytics

New & Returning Users

The new Daily Active Users chart added to the App Dashboard and App Analytics pages gives you immediate feedback on how your app community is evolving daily.

 

Region and Language Analytics

We have refactored our Region and Language analytics processing - and added new pages to better communicate who is using your app!

 Notice - these screens will not be available until the nightly jobs can generate the required data. 

Store Analytics

The new Store Analytics page shows your app’s financial performance by platform.

 Notice - this screen will not be available until the nightly jobs can generate the required data. 

Usage

API Usage

The API Usage screen now displays trend icons depicting how this month’s extrapolated usage compares with the previous month.

Monthly History

Speaking of previous months - you can now travel back in time to see what your app’s usage looked like in previous months!

Script Usage

We have added a new chart to the Script Usage screen to help you zero in on the cloud code scripts that could benefit most from optimization. 

Just bring up the page - and work your way down the list from top to bottom!

Remember - fewer API calls → fewer server resources → faster responses → lower costs. It’s win:win:win!

Usability

API Explorer & Portal Authentication

We have replaced the default Authenticate and [Quick Auth] features in the API Explorer and Script Editor with a new Portal authentication type.  This new identity type is only useable from within the Portal - and can be attached to any end-user account.

This change fixes an issue where [Quick Auth] would not work properly for apps that had Password Enforcement standards enabled. 

Note that “Portal” auth is the new default authentication type for the API Explorer.  The first time you use it it will by default create a new user account with that identity type.  It uses the email address associated with your Portal account as the id.

If you would like to attach that Portal identity to an existing end-user account:

• Log into the API Explorer as that end-user account.  This would normally be accomplished by finding the user via the User Browser, and then clicking the [Login as User] button.
• Attach your Portal identity to the account. In the API Explorer, navigate to the Identity service and Attach operation. Your portal email address will automatically be filled into the externalId. Leave all other fields as is. Click [Execute].

And voila - from now on, clicking [Quick Auth] will log into the account that you selected!

 

User Activity

We have added an informative preview pane to the User Activity screen.  Now if you click on a login entry - you’ll see a summary of what changed during that play session!  Increased/decreases in XP, purchases, virtual currencies - etc. Super helpful!

 

Advanced Settings > Compatibility Flags

This screen has been enhanced to make it easier for developers:

• Compatibility flags are now listed from newest to oldest - and we even display the brainCloud release in which a particular flag was added.
• By default - only the enabled flags are shown. [No reason to show old flags that do not apply for your app!].  Remember - when we add new compatibility flags to the system - they are automatically enabled for your app. We encourage devs to review whether they need a flag enabled though - and disabled it if they do not. brainCloud apps will perform best with all compatibility flags disabled!
• Flags are now searchable! ← note - be sure to uncheck the [x] Only show enabled option to search across all flags.

Filtered Global Entity Exports

The App > Global > Global Data > Global Entities screen now allows you to export a sub-set of a type of Global Entities.

Simply use the [Refine] button to find a subset of the entities - and then export as normal from the Bulk Actions menu. You’ll notice “filtered” in the export options - confirming that it is a subset of the objects that will be exported.

 

---

API Changes

The following enhancements have affected the brainCloud API:

• AppStore Service

  • [New!] SysGetTransactionsPage(), SysGetTransactionsPageOffset() - new methods for returning a summary list of a users' purchases.  Note - does not include all fields. 
  • [New!] SysGetTransactionDetails() - returns additional information about the specified transaction.

• Event Service

  • [New!] UpdateIncomingEventDataIfExists() - a variant of UpdateIncomingEventData() - but doesn’t write an error log entry if the evId specified no longer exists.  Useful for keeping the error logs clean when that’s a normal use case.

• Leaderboard Service

  • [New!] IfExists variants of calls won’t log an error if the leaderboard does not exist. Helps to keep your logs clean!

    • GetGlobalLeaderboardPageByVersionIfExists()
    • GetGlobalLeaderboardPageIfExists()
    • GetGlobalLeaderboardViewByVersionIfExists()
    • GetGlobalLeaderboardViewIfExists()
    • GetPlayersSocialLeaderboardByVersionIfExists()
    • GetPlayersSocialLeaderboardIfExists()
    • GetSocialLeaderboardByVersionIfExists()
    • GetSocialLeaderboardIfExists()
  • [New!] PostScoreToDynamicLeaderboardUsingConfig() method has been added to all client libraries. This is a much more flexible version of PostScoreToDynamicLeaderboard() which is now deprecated.  In particular,  PostScoreToDynamicLeaderboardUsingConfig() allows dynamically created leaderboards to have an expiry TTL - which is highly recommended for timed leaderboards!

• Lobby Service

  • [Improved!] FindOrCreateLobby() and its variations now send additional RTT events if/when hosted Room or Relay Servers are being launched. These events are entirely informational and can be ignored - though developers may want to use them to trigger on-screen updates for the end user.

• Tournament Service

  • [Improved!] GetMyDivisions() - now returns divisions that have been claimed in a new COMPLETE status…  Completed divisions will be returned as long as the associated leaderboard data is still available.

We have also deprecated the following methods:

• Leaderboard Service

  • PostScoreToDynamicLeaderboard() - will be removed from the client libraries after September 2025. Use PostScoreToDynamicLeaderboardUsingConfig() instead. The legacy method will continue to work for apps using old client libraries.

---

Libraries and Examples

Client Libraries

All Libraries

• Removed cxId parameter from cancelFindRequest function
• Added “IfExists” versions of various leaderboard functions that do not return an error if a leaderboard does not exist or is expired)
• Added PostScoreToDynamicLeaderboardUsingConfig() function
• Added “IfExists” version of UpdateIncomingEventData() function for Event Service

braincloud-csharp (C#/Unity/Godot)

• Added conditions to correct country code to ensure consistent formatting

  • “419” would become “_LA_”
  • “Hans” and “Hant” would become “CN”

braincloud-unreal-plugin (Unreal)

• Fixed compatibility issues with Unreal Engine 5.4

braincloud-cpp (C++)

• Added conditions to correct country code to ensure consistent formatting

  • “419” would become “_LA_”
  • “Hans” and “Hant” would become “CN”

braincloud-js (JavaScript)

• Fixed bug with usage of Node Buffer module

braincloud-dart (Dart)

• Pre-alpha version of our new Dart-based client library

 

S2S Libraries

brainclouds2s-cpp (C++)

• Added vcpkg.io to the S2S CPP library, allowing it to build for both Windows and Linux (MacOS still a WIP). With vcpkg dependencies are managed dynamically, so static libraries were removed from the repo and replaced with libraries that are downloaded through vcpkg.

Examples

Note: brainCloud example apps are dependent upon the brainCloud published client libraries - and are thus released in the two weeks that follow a new brainCloud release. 

Stay tuned for updates!

---

Documentation and Tutorials

BootCamp

• Additional Godot tutorials are now available!
• Updated the Portal images in many of the Unity tutorials ← PortalX is moving too fast!
• Be sure to check out bootcamp.braincloudservers.com if you haven't already!

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !

• New knowledgebase articles available:

  • Implementing a Replay System in brainCloud
  • Implementing a Jackpot System in brainCloud

 

 

brainCloud 5.3 is a significant release that reflects our goals of advancing brainCloud’s support for Product Management, Customer Support, and Multiplayer Developers in 2024.

Most urgently - this release includes support for Google’s Firebase Cloud Messaging (FCM) V1 API – just in time because the old FCM APIs will cease functioning in June 2024. Devs will want to upgrade their app configurations in short-order before the deadline.

This release includes improved handling of In-App Purchases, new Product Analytics, performance improvements for Lobby Matchmaking and Room/Relay Servers, new API calls and more! 

Finally, we have packed in a bunch more Portal polish - including our redesigned Context Banner, new User Menu, and new User Unlock feature! 

Compatibility Notes

As always - we have done all of this with an emphasis on preserving stability and backward compatibility for existing apps. Developers should be aware of the following changes:

• Google FCM HTTP v1 API - To use the new FCM API, developers must update their Google push settings to include a Service Account JSON.
• Country Codes - We have improved the country code lookup functionality in our client libraries and are now validating the codes sent to the server to enforce a standardized set. A new capability flag controls this behavior: “[x] Do not enforce valid Country code” which defaults to checked for existing apps to maintain the previous (legacy) behavior.
• Posting Scores with null extra data -  Now - if the app updates a score (via PostScoreToLeaderboard() or similar calls) while specifying null for the data parameter, the system will preserve the existing data associated with the score. (Previously, it would clear it).  There is a new capability flag to control this behavior: “[x] Do not preserve Post score with data null” - which defaults to checking for existing apps to maintain the previous (legacy) behavior.
• For apps with Tournaments and RTT - brainCloud will now send RTT-enabled events when a tournament has completed. This will allow the app to notify the user in real-time.
  Note that we did not implement a compatibility flag for this - as it should “just work” for apps that are already using Tournaments and RTT - but contact support if there are issues. We can disable it on a per-app basis!

Release Highlights

Google FCM V1 API

Google’s legacy Google Firebase Cloud Messaging APIs, which brainCloud up to 5.2 still uses, are being removed in June 2024.

brainCloud 5.3 has been updated to use the new APIs - but to do so, developers must update their Google push settings to include a Service Account JSON.  This is done via the portal's App > Design > Notifications > Settings page.

Technically devs do not need to update their client code to use the new notifications. But devs using the raw push notification methods may want to update the raw JSON they send to take advantage of new FCM V1 features.

Product transactions

We have made big improvements to the recording and reporting of Product Transactions (i.e. In-App Purchases) in brainCloud, namely:

1. We are now more accurately distinguishing between sandbox and production purchases.
2. Sandbox and Mock store purchases are no longer included in daily and monthly metrics
3. Pending purchases now expire (and are deleted) after X days
4. Mock AppStore purchases can now be performed via the Client API - but only by users flagged as “Testers” in the system

Refreshing previously calculated all-time revenue

We have added a feature to allow an app’s total revenue metric to be re-calculated… (to remove the impact of previously recorded sandbox, mock, and/or pending transactions).

This process will scan through all transactions - properly skipping over sandbox, pending, and mock transactions. 

Limitations:

• The scan does not include revenue from legacy transactions (those that occurred before November 2018)
• It also will not pick up the revenue from deleted users (as their transactions are deleted with them).
  • By default, Dormant User Deletion skips users with purchases - so the totals are unlikely to be affected by the dormant user deletion process - it would just be users with purchases that chose to delete their accounts.

Note that this process does not update previous daily or monthly totals - just the all-time revenue and purchase counts.

The function can be accessed from the Team > Manage > Apps page - by selecting “Refresh Revenue…” from the app’s action menu.

Country Codes

We have significantly improved both the:

• Retrieval of country codes [by our client libraries]
• Validation of country codes [by our servers]

Previous versions of the client libraries were simply retrieving an "assumed" country code from the locale APIs of the client device. This means that if you choose "US English" the system would assume that you are in the US - even though that just may be a language preference... (eg. lots of folks in Canada would choose "US English" simply because they prefer US spellings - like "color" instead of "colour" - "favorite" instead of "favourite", etc.). But that doesn't mean those folks are in the US!

Also - this mechanism can lead to further ambiguities - as Spanish is spoken in so many South American countries that the country code comes back as the number "419" (which indicates "Latin America Spanish").

So... here is how the new processing works (in priority order)

1. The client libs on supported platforms (iOS, Android, Playstation, etc) will now first attempt to fetch the country code from a more appropriate region selection (instead of from the language locale)
2. If that is not available, the client will use the language locale (as before)
3. If the language locale comes back as "419" (which indicates "Latin America Spanish") - our libs will convert that to a special country code of "_LA_"

And finally, our servers now validate the country code being sent to them - rejecting bad values (and preserving the existing country code stored against the account if there is one).  And note that we have the special Latin America ("_LA_") country code that we use in place of 419 if that's the only information that we have.

Important notes:

• This new country code lookup functionality is only available in the 5.3 client libraries and above - so be sure to upgrade!
• A new capability flag controls the server-side valication: “[x] Do not enforce valid Country code”.  This compatibility flag is automatically enabled for existing apps, and disabled for new apps.

Additional Improvements

But wait - there is more! Other improvements include:

• Cloud Code Scripts

  • Improved importing of scripts from zips (with folders) when the scripts do not have metadata

• Lobbies

  • Multiple improvements to Lobby matchmaking performance

• Purchases

  • Improvements to purchase data captured - now included item title and originalPrice - but drops the unused description field.

• Room Servers

  • Improved scalability of launching multiple Room / Relay Servers in parallel

Portal Changes

There are significant changes to the Design Portal in 5.3.

Context Banner

The Team / App / User Context Banner has been re-implemented to be more informative and yet take up less space on the screen. It even has a new mini version that tucks up into the corner of the screen when you collapse it! 

[New!] User Menu

The most obvious change in brainCloud 5.3 is the introduction of the new User menu. Your users are the heart of your application - and it’s about time that brainCloud treated them that way!

The User menu elevates player searches to a top-level feature and is much more accessible for non-development personnel (i.e. Customer Support Reps, etc.).

User Unlocking

To further streamline support, live user data can now be edited without fully unlocking the app. 

The new User Lock is a single-click mechanism that unlocks a specific user for editing (by the local Portal user). This mechanism is quicker, safer, and less scary than fully unlocking an app to make changes.

User Summary Data

User Summary Data is now displayed more prominently throughout the portal. You’ll see it in User Previews and on the revamped User Summary page itself - where you can even edit it directly!

User Virtual Currency

The User Virtual Currency screen has been enhanced with a chart of the user’s currency balances for the past 30 days.

In-App Purchase Transactions

Two new screens have been added to the portal:

Global Transactions

The new Global Transactions screen (available at App > Global > Marketplace > Transactions) provides a view of recent IAP purchases by app store.  Note that users without the All or Reporting Role permissions can only see item counts - they do not see revenue totals.

Product Analytics

The new Product Analytics screen (available at App > Reports > Analytics > Product) for all users with All or Reporting Role permissions, provides an overview of purchases by product for the selected timeframe.

My Servers

We have improved the configuration dialog for Room and Relay Server hosting to better communicate the performance and/or cost impact of certain settings.

The most common confusion is how Min Ready Containers combines with Containers per Server to affect the number of servers that are running 24x7 - even if they are idle. 

Explanation:

• Setting Min Ready Containers to > 0 reduces the average launch times for Room and Relay Servers, because brainCloud will attempt to keep enough server VMs running with free spots for the specified number of containers. We call this feature Quick Launch.
• For example - If Min Ready Containers is set to 8, and Containers per Server is set to 4, a minimum of 2 servers will run at all times to satisfy the Min Ready Containers requirement.
• Furthermore, in the above example, if Containers Per Server were changed to 1, it would mean that 8 servers would run at all times!

This can lead to surprising bills for customers - which obviously is not what we want. 

The My Servers list page now displays:

• Quick Launch - an icon to indicate that Min Ready Containers is > 0 - which allows matches to start faster since there should generally be a warm server around to host them
• Idle Servers - a calculation of the minimum number of servers that will be running at all times - so that the developer has a heads up! 

In addition - we have added additional help text and costing indicators ($ - $$$$$) to help developers better understand the cost impact of the configuration settings.

API Changes

The following changes/additions have affected the brainCloud API:

• AsyncMatch

  • The new UpdateMatchStateCurrentTurn() function - which allows the current player in the game to overwrite the matchState and statistics without completing their turn or adding to matchHistory

• Group

  • The new DeleteGroupJoinRequest() method allows an end-user to delete their request to join a group.

• Leaderboard

  • The new SysDeleteLeaderboardConfig() method allows devs to delete leaderboards even if tournaments are configured against them. This method is available in Cloud Code only.

• PlayerState

  • New UpdateCountryCode() method that allows a user’s country code to be updated. This method is available in Cloud Code only.

• Tournaments

  • New behavior - for apps with Tournaments enabled - brainCloud will now send RTT-enabled events for when a tournament has completed. This can allow the app to notify the user in real-time.
    Note that we did not implement a compatibility flag for this - as it should “just work” for apps that are already using Tournaments and RTT - but contact support if there are issues. We can disable it on a per-app basis!

Client Libraries

All Libraries

• Created canReconnect() helper method that returns true if there are stored Anonymous and Profile IDs on the device that can be used for reconnect authentication
• Added logout functions to Wrapper for application close events
• Changed how country code is retrieved on devices, instead of getting the country code from the language selection locale, there is now specific code per platform to fetch the country code from a more appropriate region selection on the supported OS platforms. (PC, Mac, Android, iOS, PlayStation, Nintendo)
• Added updateMatchStateCurrentTurn() function: Allows the current player in the game to overwrite the matchState and statistics without completing their turn or adding to matchHistory

braincloud-csharp (C#/Unity/Godot)

• as above

braincloud-unreal-plugin (Unreal)

• Added new module to plugin that provides access to native Android functions to get device information, including a function that gets the country code of the device. It first attempts to get it from the SIM card, if the device doesn’t have a SIM card, it tries to get it from the connected wi-fi network and if the device is not connected to any network, it will default to getting the country code from the selected Language (country) locale.

braincloud-cpp (C++)

• as above

braincloud-java (Java)

• as above

braincloud-js (JavaScript)

• Added logout functions to Wrapper for application close events

  • logoutOnApplicationClose() uses the Fetch API to send a logout request. When triggered by a "beforeunload" event, this attempts to send the request when the page/tab is closed/refreshed
  • runScriptAndLogoutOnApplicationClose() is similar to logoutOnApplicationClose(), but it sends a request to run a Cloud Code script before logging out

S2S Libraries

• no updates

Examples

All Examples

• Added logout on windowClosing for all demos
• Added logout buttons to applicable demos

• Implemented reconnect authentication in applicable demos

  • attempts reconnect automatically on app start and displays login fields if not successful

examples-unity (C# Examples)

• Bombers, BCChat, TicTacToe all got updates and bug fixes
• BC Clashers UI overhaul, gameplay features added
• Invaders: Added features for when a user is connecting to a room

examples-godot (Godot Examples)

• Improved RelayTestApp demo

example-csharp (Xamarin Examples)

• Xamarin examples updated

examples-java (Java Examples)

• Added logout on windowClosing for RelayTestApp
• Added logout buttons to Android demos

• Implemented reconnect authentication

  • attempts reconnect automatically on app start and displays login fields if not successful

examples-javascript (JavaScript Examples)

• Implemented new logout functions as described in the brainCloud-JS changes above so that the examples will automatically logout when closed
• Added logout buttons to RelayTestApp and Warstone as there was previously no way to logout of these examples manually

• RelayTestApp now uses getLobbyData()

  • populate lobby types options list
  • read rules to determine if users can join in-progress matches or return to lobby with same members (END_MATCH)
  • read teams to determine game mode (Free-For-All or Team)

examples-unreal (Unreal Examples)

• Improved test app for deployment to consoles and devices
• reconnect and logout features as above, plus Remember Me feature
• BCChat, Relay Basters and Tappy Chicken various improvements, features, bug fixes

braincloud-roomserver-unreal (Dedicated Demo)

• reconnect and logout features as above

examples-swift

• reconnect and logout features as above

examples-cpp

• reconnect and logout features as above

Documentation and Tutorials

BootCamp

• More Godot BootCamp video lessons

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !