How to Get a Py2Native Pro License
If you are evaluating the Py2Native Pro license, the decision usually comes down to one question: do you only need to compile your Python code into native binaries, or do you also need a compiled-in way to enforce who can run those binaries? The Pro license adds license verification and string compression on top of the open-source compiler. This article walks through what you get, how the purchase and activation flow works, and whether the upgrade makes sense for your commercial Python product.
If you are still deciding whether native compilation is the right protection strategy at all, see Python Obfuscation Techniques: Do They Really Protect Your Code? and Challenges Faced by Python Developers Shipping Proprietary Software.
Making the Case for Py2Native Pro
Py2Native compiles your custom Python code into native machine code. You write plain Python, run one uv run py2native build command, and get a compiled executable or shared library instead of readable .py files. The community edition is MIT-licensed and already includes full compilation, uv embedding, and cross-platform support.
The Pro edition is for teams that need more than code protection. It is a closed-source plugin that adds two capabilities:
- JWT license verification compiled into your executable
- String compression to further obfuscate embedded strings
The Pro plugin requires a valid license during builds. If you ship proprietary software and want to control which customers can run your compiled binary, the Pro license is the practical upgrade path.
Py2Native does not ask you to hand-write Cython, manage .pyx files, or build C extensions. The compiler hides that complexity. The Pro plugin does introduce one small .pxd integration file for license verification, but that file is provided with the plugin—you are not authoring Cython from scratch.
What You Get with Py2Native Pro
Py2Native Pro adds a licensing workflow that is compiled directly into your application. The main pieces are:
- EC P-256 keypair generation
- JWT signing and license file creation
- License verification that runs inside your native binary
- String compression for additional protection of embedded values
The CLI commands are available through the normal Py2Native entry point:
# Generate an EC P-256 keypair
uv run py2native keygen private.pem public.pem
# Sign a JWT payload with the private key and create a license file
uv run py2native sign --private private.pem \
'{"customer":"acme-corp","plan":"pro","exp":"2027-09-03"}' \
license.dat
# Inspect the JWT claims and optionally verify the signature
uv run py2native show --public public.pem license.dat
The payload above is an example; your claims should match your own licensing model.
When you build with Pro, the public key and verification logic are baked into the executable. The private key never ships with the application. This means your binary can verify a license without calling an external service or loading a third-party crypto library at runtime.
To call the compiled verification logic from your application, the Pro plugin provides a .pxd file. The exact names may differ with your Pro distribution, but the integration shape looks like this:
cdef _runtime_verify_es256_jwt(token, expected_iss=*, expected_aud=*)
Then your Python code can enforce the license early in startup:
# The import name below is illustrative; use the module supplied by the
# Pro plugin distribution.
from pro_license import py2nativepro_verify_license
def enforce_pro_license(license_path: str) -> None:
with open(license_path, "r", encoding="utf-8") as f:
token = f.read().strip()
if not license = _runtime_verify_es256_jwt(licenseString, expected_iss="RSJ Software GmbH", expected_aud="TimestampGIT"):
raise RuntimeError("Invalid or expired Py2Native Pro license")
Because the Pro plugin compiles the verification code into the executable, the license check becomes part of the same native binary you are already shipping. You do not need to deploy a separate license server or add a runtime dependency for EC verification.
Cost-Benefit and ROI of Pro
The main financial argument for Py2Native Pro is revenue protection. If your compiled Python application can be copied and run by unauthorized users, a Pro license may pay for itself the first time it blocks unlicensed distribution.
Implementing your own license verification usually involves more than a few lines of Python. You need to choose a key format, manage public and private keys, decide on a token format, handle signature verification, embed the public key, and ensure the verification code cannot be trivially patched out. Py2Native Pro provides that mechanism already compiled into the binary.
The Community edition remains free and open source. That makes the upgrade path low-risk: you can start with basic native compilation, prove that it fits your build process, and add Pro only when you need licensing enforcement or string compression.
Pro reduces development time and security risk by giving you a tested licensing mechanism out of the box. Instead of building your own crypto integration, you run keygen, sign, and show, then reference the license file during your normal Py2Native build.
Upgrade Path and Deployment Options
Py2Native Pro is an add-on to the open-source core. You keep the py2native compiler and add the proprietary py2nativepro plugin to your environment. The Pro plugin extends the normal build pipeline through Py2Native’s plugin system.
Py2Native is self-hosted. You run the compiler on your own machine or CI/CD infrastructure. There is no required cloud component for normal builds, and the Pro license is a file you provide during the build process.
When you build with Pro enabled, use the --license flag to point at your JWT license file and --public to point at the public key:
uv run py2native build \
--license license.dat \
--public public.pem \
main.py *.py
This works for both executable mode and library mode. To build a protected shared library instead of a standalone binary:
uv run py2native build \
--library \
--license license.dat \
--public public.pem \
main.py *.py
Because the Pro plugin extends the standard build flow, it also supports the wheel and embed outputs where applicable. The license verification code is included in the compiled result, while your third-party Python dependencies remain as normal Python packages.
How to Purchase and Activate
This article does not include pricing details because pricing is not provided in the available product information. For current pricing, contact the official Py2Native website or sales channel.
The general activation flow is straightforward:
- Obtain a license file in JWT form from the vendor.
- Generate or receive your EC P-256 keypair if you do not already have one.
- Place the license file and public key in your project or build environment.
- Reference the license file during builds with
--license. - Reference the public key during builds with
--public. - Run your normal Py2Native build command.
For example:
uv run py2native build \
--license license.dat \
--public public.pem \
main.py *.py
The Pro plugin is proprietary and requires a valid license during builds. The Community edition remains free and open source, so teams that only need compilation can continue using it without a Pro purchase.
FAQ
What is the difference between Py2Native Community and Pro?
The Community edition is open source under the MIT license and provides full Python-to-native compilation, uv embedding, and cross-platform support. The Pro edition adds JWT license verification and string compression. Pro is distributed as a proprietary plugin and requires a valid license to use.
How does Py2Native Pro license verification work?
Pro uses EC P-256 key pairs. You generate a keypair with uv run py2native keygen, sign a JWT payload with the private key to create a license file, and then build your application with the --license flag. The public key and verification logic are compiled into the executable, so no external libraries are needed at runtime.
Can I try Py2Native Pro before buying?
The product information does not specify a trial version. The Community edition is free and open source, so you can evaluate the core compilation features. For Pro features, you would need to contact the vendor for licensing options.
Is Py2Native Pro a cloud service or self-hosted?
Py2Native is a self-hosted tool. You run the compiler on your own machine or CI/CD environment. The Pro license is a file that you provide during the build process; there is no cloud component required.
Conclusion
The Py2Native Pro license is the commercial add-on for teams that need compiled license enforcement and string compression on top of Python-to-native compilation. The purchase decision is really about control: Community protects your code, while Pro also protects your revenue by embedding JWT verification directly into the binary.
Start with the Community edition if you only need compilation. Upgrade to Pro when you need a tested, self-hosted licensing workflow without building your own crypto integration. For current pricing and license options, check the official Py2Native website.
Related posts
- Challenges Faced by Python Developers Shipping Proprietary Software
- Python Obfuscation Techniques: Do They Really Protect Your Code?
- Automating Python to Native Compilation in CI/CD
