Seal the files you ship

Turn on sealed files

1. Step 1Turn it on from the product page

   Open the product from Products in the left menu, and press Turn on sealed files in the Sealed files section. Read the confirmation message and continue, and it's on right away. Owners, admins and members can do this.

   You can also ask an AI assistant. If its connection has “Allow product, policy, and webhook configuration” under Access to grant, ask “Use the Usakey MCP skill to turn on sealed files for this product and tell me its sealing key” (it can't be turned off afterward, so the AI confirms with you first). If the connection doesn't allow that, the AI will point you to this page.

   Once on, it can't be turned off, because files you have sealed and shipped would stop opening. On the Evaluation plan the section shows Not in your plan and it can't be turned on.

   View full size

2. Step 2Copy the sealing key

   Once it's on, Sealing key (public) shows one line starting with usakey-sealing-key:v1:. Copy it with Copy key and give it to the sealing tool.

   This line is not a secret, so it can live in your build settings, such as a CI variable. The private key that opens the files never leaves Usakey (in production it stays inside a key management service that never releases the key). The key part of the line is the same for every product in the environment: the environment shares one key, and products are told apart by the product ID and key ID in the line, so another product's app can't open your files. You can get the same line with GET /mgmt/v1/products/{product_id}/sealed-files in the Management API, or with get_product_sealed_files from an AI assistant (MCP).

   View full size

Seal your files

1. Step 3Seal your files

   The easiest way to seal is to ask your AI assistant. The files are sealed on your own machine and are never sent to Usakey.

   Ask your AI Seal with a command

   Paste this prompt into your AI assistant. Replace the file name and the entitlement name with your own.

   Use the Usakey MCP skill to seal models/pro.onnx, which ships with my product, so that it opens only on devices with a valid license. Use the sealing key line I copied from this product's page in the Console (it starts with usakey-sealing-key:v1: and I'll paste it here). Only Pro licenses should be able to open it, so give it the entitlement pro_model and write it next to the original as models/pro.onnx.sealed. Keep the original out of what I ship.

   Copy

2. Step 4Ship the sealed files with your product

   Put the sealed files in your installer or container image. Don't ship the original files.

   Each file is sealed with its own random key, so sealing the same file again produces a different file. When you ship a newly sealed file, each device fetches its key once more the first time it opens it. To seal files from your build system, you can also use the sealing function in the Rust, C ABI, Node.js, Python and Ruby SDKs (it produces the same format).

Open them in your app

Building this into your app is also easiest with an AI assistant. Connect it the same way as in Add license checks to your app and ask like this. Replace the file name and the entitlement name with your own.

Use the Usakey MCP skill to make this app open models/pro.onnx.sealed with its license. Load it only when the pro_model entitlement is on, and when it can't be used, fall back to the standard model and show the reason.

The AI writes the code that reads the file with the SDK's open-sealed-file function, and tests for it. It's available in the Rust, C ABI (C), Node.js, Python and Ruby SDKs. The SDKs for other languages don't support it yet. The SDK function works like this.

• Every time it opens a file, it checks the current license decision and opens the file only when use is allowed. If the file has an entitlement name, the decision is made for that entitlement.
• Only the first time a device opens a file does it contact Usakey to receive the key (this uses one Runtime API call from the monthly allowance). The device stores the key and opens the file without connecting after that.
• The SDK never gives your app the key that opens the file; it returns only the opened data.

To build it yourself, see Receive the key for a sealed file in the developer documentation.

Example: a machine-learning model and its preprocessing

This example ships trained weights and preprocessing parameters (feature order, means and standard deviations, the decision threshold, and so on) with the product so that only the product app on a device with a valid license can read them. The SDK's python/examples/sealed_model has a version you can run, from training and sealing to loading and scoring in the app (Python standard library only).

1. Seal in your build. Write the weights and the preprocessing to files and seal each with the sealing key. Give the high-accuracy model an entitlement (for example pro_model). Ship only the .sealed files.
2. Pin the plaintext hashes in the app. In the same build, compute the SHA-256 of each file before sealing and embed it in the app's code. A hash doesn't reveal the weights. A fake file made by someone who knows the sealing key opens, but its hash doesn't match, so the app doesn't load it.
3. Load in memory. Load the data the SDK returns as it is, and never write it to disk, logs or temporary files. Pick formats that load from bytes (ONNX Runtime's InferenceSession(data), safetensors, NumPy .npz without pickle, JSON, and so on).

# Your build (seals with the public key only)
usakey.seal_file(sealing_key, "model.onnx", "dist/model.onnx.sealed", entitlement="pro_model")
usakey.seal_file(sealing_key, "preprocess.json", "dist/preprocess.json.sealed")
print(hashlib.sha256(open("model.onnx", "rb").read()).hexdigest())  # embed in the app

# The product app (checks what it opened, then uses it in memory)
model = client.open_sealed_file("dist/model.onnx.sealed")
if not hmac.compare_digest(hashlib.sha256(model).hexdigest(), MODEL_SHA256):
    raise RuntimeError("This is not the model this app was built with")
session = onnxruntime.InferenceSession(model)

• A license whose entitlement isn't turned on (true) can't open the high-accuracy model (in Python, LicenseDeniedError with the reason EntitlementMissing). The app can switch to the standard model and keep working.
• Don't load pickle-based formats (joblib, torch.load by default, and so on) from sealed files. A fake file could make your app run arbitrary code.
• An administrator of the device can extract the weights from memory after the app loads them. If the weights must never reach devices, run inference on your server instead.

Fully offline devices

Devices without an internet connection can open sealed files too. Fully offline activation (Offline Activation) is available on the Team plan and above.

• When the device creates its request file (.usakeyreq), include the sealed files (up to 16 per request). Only the files' headers go into the request file.
• When you issue the license file (.usakeylic) in the Console or with the Management API, the keys for those files go into it. If the key for even one file can't be delivered, nothing is issued and the reason is shown (a file for another product, an entitlement that isn't true, a plan that doesn't include it, and so on).
• After loading the license file, the device opens the files without connecting. To add another file later, create a new request file and issue the license file again.

How to exchange request and license files is in Steps for fully offline devices in the developer documentation.

When a file doesn't open

What your app receives and what to check. None of these deactivates the device.

When Usakey refuses to deliver a key, open the device on the license in the Console: "Requests refused in the last 7 days" shows the reason and how many times it happened. The product app refuses some files itself before connecting (a file for another product, an entitlement that isn't true, and so on). Those don't appear there, so check the code or decision the product app received.

You can check which plans include sealed files in the comparison table on the pricing page.