Godot SDK: License Keys, Offline Access and Paid Features in GDScript
Add product-scoped license activation and paid features to Godot with native GDScript, signed offline proof and a working desktop demo.
Godot License Keys and Offline Licensing | Native GDScript SDK
Follow a native Godot integration, accepted and rejected desktop license checks, and the trust boundaries for offline proof and floating seats.
Open on YouTubePermitCore now has a native Godot SDK. Version 2.2.0 adds license activation, feature checks, floating seats, metering and signed offline verification to GDScript projects. It is our ninth SDK, and your game does not need the .NET edition of Godot, a GDExtension binary or an external cryptography package to use it.
This walkthrough focuses on a desktop game or tool sold directly to customers. If you distribute through a game marketplace, check its rules before adding a separate activation requirement. Your game's licensing policy and the SDK's open-source license are separate decisions.
Install the native GDScript add-on
Get the published 2.2.0 release,
or download the complete Godot example from the Sandbox. Copy
addons/permitcore/ into your project's res://addons/permitcore/ folder.
The optional editor plugin makes no automatic network requests and stores no credentials.
The add-on targets Godot 4.7+. Our checks use Godot 4.7.2. You can also install version 2.2.0 from the Godot Asset Store. Its public listing and download were verified on November 20, 2026.
The SDK uses MIT. Keep its copyright and license notice with distributed copies. Godot itself also uses MIT and permits commercial projects under other licenses; include the engine and relevant third-party notices. See Godot's license guidance.
Create the product and a test license
In PermitCore Admin, create a product for your game, then create and save a TEST license for
that product. Add a pro feature if it should unlock your paid edition. Copy the
product ID for the integration. Test licenses label development records; their occupied device
seats still count toward account capacity.
A license key belongs to the customer-facing flow. An Admin API key, tenant passphrase, payment secret or private signing key does not belong in the exported game. The passphrase protects browser-created license material in Admin; online validation still sends the supplied license key to the configured API over HTTPS.
Activate an installation, then validate its entitlement
This is the same native example used in the SDK reference and Admin integration snippet.
Replace the public-key placeholder with independently trusted vendor configuration. Use your
own API origin when self-hosting. Call these methods from the SceneTree thread with
await; their requests yield frames so the interface can remain responsive.
extends Node
# Copy addons/permitcore into res://addons/permitcore first.
const PermitClient = preload("res://addons/permitcore/permitcore_client.gd")
var client = PermitClient.new("https://api.permitcore.dev", {
"trusted_public_keys": ["YOUR_TENANT_SPKI_BASE64_PUBLIC_KEY"],
"cache_directory": "user://permitcore"
})
func can_use_pro_features(key: String, product_id: String) -> bool:
var result = await client.validate(key, "1.0.0", product_id)
return result.is_valid and result.has_feature("pro")
func register_installation(key: String, product_id: String) -> bool:
var result = await client.activate(key, "", "My Godot app", "1.0.0", product_id)
return result.is_validactivate() registers the installation using the SDK's nonce flow. A later
validate() checks its current entitlement. Always pass the expected product ID;
a valid license for a different product must not unlock your game. The SDK generates a
persistent installation identifier by default. If your product supplies its own identifier,
keep it stable across restarts and deliberate about reinstalls.
Connect the returned boolean to your real feature boundary: CSV export in a tool, additional content in a game, or another clearly defined entitlement. Keep an error message and a recovery path visible when the server refuses access. Avoid validating on every frame; choose explicit startup and refresh points that fit your product.
Try the complete Godot demo in the editor
The Sandbox ZIP contains an importable Task Manager Pro project with the canonical
add-on already included. Open its project.godot in Godot and run the main scene.
The Community workspace allows three fictional projects and disables CSV export. An accepted
license with pro enables the paid feature. The demo explicitly labels its data
as fictional and masks the key input.
The SDK operations tab exposes floating-seat actions, metering and removal of a specified owned device. The offline tab verifies configured signed proof without displaying token text. Use owned test licenses and return floating sessions after testing. Removing a device is an explicit operation; a failed request must not be presented as a successful removal.
Offline access needs a trust policy
A successful online response can supply signed outage proof when the server policy allows
it. Before using that proof offline, the SDK checks the signature, independently configured
public key, license/product/device context and signed deadlines. An empty
trusted_public_keys list does not authorize cached access.
A transport outage and an explicit business denial have different meanings. A rejected key, wrong product or malformed successful response must not silently unlock cached Pro access. Manual activation also needs an authentic signed token, matching context and a valid deadline.
Offline verification cannot discover a later server revocation while disconnected. An existing valid signed proof can remain usable until its signed deadline. Choose that window deliberately and explain it to customers. The full Godot reference covers the configuration and complete method surface.
Floating seats, usage and direct sales
For concurrent seats, check out a floating session, renew its heartbeat while the licensed work continues, and return it when the user finishes. Your application must stop the protected work when the lease is refused or expires. Do not interpret an unconfirmed return as a released seat.
Metering reports configured usage events. Check the returned recorded result; a request that did not record an event is not billing evidence. Usage reporting alone does not collect a payment.
If you want a direct-sales workflow, the optional PermitCore Store connects product checkout to license delivery. Hosted plans and payment-provider charges are separate from this free SDK. Buyers obtain their keys through their verified Store account; license keys are not delivered in email. A third-party game's marketplace can impose a different purchase flow.
What we tested, and what you still need to test
The release passed 272 native checks with Godot 4.7.2, including HTTP/TLS behavior, signature verification, context attacks, response mapping and timeouts while the game loop is paused. SDK CI also exercises Windows, Linux and macOS. Actual hosted checks cover activation, feature and product checks, bounded offline proof, manual tokens, metering, floating seats, device removal and revocation using owned TEST licenses.
We also checked the Windows editor and an interactive Windows desktop export, plus startup of a Linux x86_64 desktop export in headless mode. These results do not certify mobile, Web, console or macOS export targets. Test your exported game, its network restrictions, trust configuration and failure behavior before shipping. Client-side licensing code can be modified; it is not an unbreakable DRM boundary.
Start with the complete Godot integration tutorial, run the working demo, then move the same product-scoped checks into your own feature flow.
Build your first licensed product without building a license server.
Create a free PermitCore account, issue a test license, and validate it from your application.