The Godot community has been building increasingly ambitious games. Backend infrastructure has not always kept pace with that ambition. Today that changes.
The AccelByte Gaming Services SDK is now available in the Godot Asset Library.
It is a native GDExtension plugin for Godot 4, callable directly from GDScript, with no separate build toolchain required. Backend features your game needs, accessible from the same editor you already work in.
What the SDK Includes
The SDK surfaces the full AccelByte Gaming Services platform from within Godot:
That is the core of it. The platform itself runs deeper and they are all accessible from the same SDK.
You still control the game logic
Out-of-box systems handle the common cases. What makes a game distinct is the custom behavior layered on top of them.
That is where AccelByte Extend comes in. It lets you write custom server-side logic such as reward conditions, progression rules, validation and run it inside the backend, next to systems it needs to interact with.
Say only ranked matches should grant seasonal rewards. That rule lives in an Extend app. When a match ends, the backend runs your logic, checks your conditions, and updates relevant systems. The rule is yours. The platform handles the rest.
You are not fitting your game into a default flow. You are defining the flow.
Why this matters for Godot developers
Say you are building a top-down survival game. Single developer, no team. You want players to have persistent accounts, a global leaderboard to drive replayability, and cloud saves so progress is not lost.
Without a backend solution, you are looking at weeks of work before any of that is functional. Server setup, user management, a database, an API layer connecting it all. And then you have to maintain it.
With the AccelByte SDK, each of those features is a few GDScript calls. You install the plugin from the Asset Library, configure your credentials in project.godot, and you are building the actual game.
Who actually needs this
A purely offline game may not need a backend. But even single-player projects can benefit from services like authentication or cloud saves that keep player progress safe across sessions and devices.
But if your game has any of the following, the infrastructure cost is real:
For those projects, building backend infrastructure from scratch is not a creative decision. It is overhead that competes with the time you actually want to spend on your game.
How to get started
Getting credentials takes about five minutes. Register for a free account at gamingservices.accelbyte.io, create a game namespace, and copy the client ID. That is everything the SDK needs.
Installation is through the Godot editor. Open the AssetLib tab, search for "AccelByte SDK," download and install. Then add three lines to project.godot:
[accelbyte] base_url="https://my-game.prod.gamingservices.accelbyte.io" namespace="your-namespace" client_id="your-client-id
From there, every service is accessible from GDScript. Here is what player authentication looks like:
var sdk: AccelByteSDKWrapper
func _ready() -> void:
sdk = AccelByteSDKWrapper.new()
sdk.initialize(self)
# Configure SDK from project settings
var base_url = ProjectSettings.get_setting("accelbyte/base_url", "")
var namespace_ = ProjectSettings.get_setting("accelbyte/namespace", "")
var client_id = ProjectSettings.get_setting("accelbyte/client_id", "")
var client_secret = ProjectSettings.get_setting("accelbyte/client_secret", "")
sdk.set_server_url(base_url)
sdk.set_client_credentials(client_id, client_secret)
sdk.set_namespace(namespace_)
# Perform device login
var iam = sdk.get_iam_service()
# Generate a unique device ID (or use OS-specific ID)
var device_id = OS.get_unique_id()
if device_id.is_empty():
device_id = str(Time.get_unix_time_from_system()).md5_text()
print("Logging in with device ID: ", device_id)
var result = await iam.platform_token_grant_v4("device", "", "", true, device_id)
if result.get("success", false):
# Tokens are automatically stored by the SDK
print("Login successful! User ID: ", sdk.get_user_id())
else:
print("Login failed: ", result.get("error_message", "Unknown error"))
Every other service in the SDK follows a similar pattern: get the service, make the call, handle the result.
Working examples for leaderboards, cloud saves, and more are in the examples directory on GitHub.
Godot developers deserve a backend layer that is accessible and able to keep up. We think the AGS SDK is a meaningful step in that direction, and we are looking forward to seeing what gets built with it.
You can sign up, get your namespace and client ID, and have a player logged in before you spend anything or even enter your credit card details.
The free tier is designed to cover you through development and early testing. As your player base grows, AccelByte's pricing scales with you rather than hitting you with a cliff the moment you get traction.
Feedback, bug reports, and platform requests are welcome in the Discord.
...