All guides

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 licensing illustration for Godot SDK: License Keys, Offline Access and Paid Features in GDScript
Watch the native Godot walkthrough

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 YouTube

PermitCore 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.

GDScript
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_valid

activate() 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.

Put the guide into practice

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.