Py2Native Pro License Pricing: What’s Included?

If you are shipping proprietary Python software, the purchase decision usually comes down to one question: does the commercial upgrade pay for itself in reduced piracy and better control over distribution? Py2Native Community already gives you zero-config Python-to-native compilation, but Py2Native Pro adds license verification and string compression on top of that foundation.

This article explains what you get in each tier, how the Pro licensing model works, and how to decide whether the upgrade is worth it for your product.

Understanding Py2Native Pro: The Commercial Upgrade

Py2Native is split into two tiers:

The Community edition is the open-source compiler. It takes your normal Python files and compiles them into native machine code without requiring you to write Cython syntax, maintain .pyx files, or manually run a C extension build. You write plain Python and run:

uv run py2native build main.py *.py --embed dist/your-app

Py2Native Pro is not a separate compiler. It is a proprietary plugin that extends the open-source core. The build orchestrator already exposes plugin lifecycle hooks, and the py2nativepro package plugs into those hooks to add commercial features before, during, and after compilation.

The important point for a buying decision: Pro does not change the zero-config workflow. It adds licensing capability on top of the same uv run py2native build command.

What’s Included in Py2Native Pro

Pro adds two headline features on top of the Community compiler:

1. JWT license verification
2. String compression

The license verification feature is the main reason most teams buy Pro. It gives you a complete command-line workflow for creating and checking signed license files:

uv run py2native keygen private.pem public.pem

This generates an EC P-256 keypair. The private key stays on your machine for signing licenses. The public key is later embedded into your compiled executable.

To create a license file, sign a JWT payload with the private key:

uv run py2native sign --private private.pem \
  '{"sub":"customer-123","iss":"RSJ Software GmbH","aud":"TimestampGIT"}' \
  license.dat

The resulting license.dat is what you distribute to a customer.

You can inspect a license file with:

uv run py2native show --public public.pem license.dat

The show command displays JWT claims and can verify the signature against the public key.

On the code side, Pro does not require you to write C extension logic by hand. You add a small .pxd declaration so your plain Python can call the compiled verifier:

# py2nativepro_license.pxd
from _p2n_bootstrap cimport _runtime_verify_es256_jwt
cdef _runtime_verify_es256_jwt(token, expected_iss=*, expected_aud=*)

Then in your application entry point, you call the verifier at startup:

# main.py
from pathlib import Path

def enforce_license():
    licenseString = Path("license.dat").read_text().strip()
    license = _runtime_verify_es256_jwt(
        licenseString,
        expected_iss="RSJ Software GmbH",
        expected_aud="TimestampGIT"
    )
    if license is None:
        raise SystemExit("Invalid Py2Native Pro license")
    return license

enforce_license()
# Your proprietary application code starts here.

The important property for commercial software: only the public key is stored in the executable. The elliptic key verification is handled with compiled code inside Py2Native Pro, so you are not depending on third-party license-verification libraries at runtime.

The second Pro feature, string compression, is included alongside license verification. It reduces the size of string data in the compiled artifact, which can matter for large codebases or deployments where binary size is a concern.

Pricing and Licensing Model

Py2Native Pro pricing is not listed publicly in the current product information. If you need commercial terms, contact the vendor for a quote.

What is documented is the licensing mechanism. Pro uses JWT-based license files signed with an EC P-256 private key. The workflow is self-hosted:

1. You generate a keypair with uv run py2native keygen.
2. You sign a JWT payload with uv run py2native sign.
3. You distribute the resulting license.dat to customers.
4. Your compiled application verifies that file at runtime using the embedded public key.

There is no cloud activation server in the documented workflow. Verification happens offline inside the compiled executable.

The build itself can also require a valid Pro license. The build command accepts a --license flag:

uv run py2native build main.py *.py \
  --license pro-license.dat \
  --public public.pem \
  --embed dist/your-app

Here, --license is the commercial build license required by the Pro plugin, while --public embeds the public key used for runtime customer license checks.

Pro is distributed as a separate package, py2nativepro, under a proprietary license. The open-source core remains MIT-licensed.

Cost-Benefit Analysis: Is Pro Worth It?

The free tier is a strong choice for several scenarios:

• Internal tools that never leave your company.
• Open-source projects where source visibility is expected.
• Early-stage products that need native compilation but do not yet need per-customer licensing.
• Teams evaluating the compiler before committing to a commercial purchase.

In those cases, Community gives you the full compilation pipeline, uv embedding, and cross-platform support for no cost.

Pro becomes worth evaluating when you need to prevent unauthorized use of your compiled application. The JWT verification path lets you issue customer-specific licenses, embed a public key in the binary, and reject invalid or expired license files at startup. That is a direct revenue-protection mechanism for proprietary desktop software, on-premises tools, or any product where the binary leaves your control.

The ROI case usually includes:

• Reduced casual piracy: a signed license file is harder to copy than a plain Python source tree.
• Distribution control: you decide which claims go into each license.
• Offline verification: no runtime dependency on a licensing server.
• Minimal code impact: you add one startup check, not a new architecture.

The practical comparison is not Community versus Pro in general. It is whether the cost of a lost sale or unauthorized redistribution is greater than the cost of the Pro license. For many small ISVs selling proprietary Python tools, that math favors Pro once the product reaches paying customers.

Upgrade Path and Getting Started with Pro

The upgrade path is incremental. You do not need to rewrite your application or switch build tools.

A typical progression looks like this:

1. Start with the Community edition and compile your Python normally.
2. Add the proprietary py2nativepro package to your uv environment.
3. Generate a keypair:

uv run py2native keygen private.pem public.pem

4. Sign a license file:

uv run py2native sign --private private.pem \
  '{"sub":"customer-123","iss":"RSJ Software GmbH","aud":"TimestampGIT"}' \
  license.dat

5. Add the .pxd declaration and the _runtime_verify_es256_jwt startup check to your code.
6. Build with the --license and --public flags:

uv run py2native build main.py *.py \
  --license pro-license.dat \
  --public public.pem \
  --embed dist/your-app

Your normal Python code remains plain Python. The only Pro-specific addition is the license check. For the full step-by-step compilation flow, see the Python to Native Compiler Tutorial: Py2Native Step by Step.

FAQ

What is the difference between Py2Native Community and Pro?

Py2Native Community is open-source under the MIT license and provides full Python-to-native compilation with zero configuration. Pro adds commercial features: JWT license verification with keygen, sign, and show commands, plus string compression. Pro is a proprietary plugin that extends the open-source core.

How does Py2Native Pro license verification work?

You generate an EC P-256 keypair with uv run py2native keygen, sign a JWT payload with the private key using uv run py2native sign, and distribute the resulting license file. In your code, you call _runtime_verify_es256_jwt with the license string and expected issuer/audience. The Pro plugin bakes the signature verification code and public key into the executable, so only the public key is stored in the binary.

Can I try Py2Native Pro before buying?

The product information does not specify a trial. You can start with the open-source Community edition to evaluate the core compilation. For Pro features, contact the vendor for a quote or trial options.

Does Py2Native Pro require changes to my Python code?

Only if you want to enforce license verification. You add a call to _runtime_verify_es256_jwt in your code, typically at startup. The compilation process itself remains zero-config; you write plain Python and run uv run py2native build.

Is Py2Native Pro available for all platforms?

Pro extends the same cross-platform core, which supports Windows, manylinux2014/musl Linux, and macOS on x86-64 or ARM64 CPUs.

Conclusion

Py2Native Community is the fastest way to compile plain Python into native machine code. Pro adds the commercial layer that proprietary software often needs: signed, offline license verification and string compression, without turning your build into a manual Cython project.

If you are still deciding, start with the Community compiler. If you are already shipping binaries to customers, evaluate Pro from the perspective of how much unauthorized use costs you today. The licensing workflow is self-hosted, the code change is small, and the upgrade path is straightforward. For more about the core compiler and how it fits into a broader protection strategy, see Py2Native.

Related posts

• Python to Native Compiler Tutorial: Py2Native Step by Step
• What Is Python to Native Compilation? A Beginner’s Guide
• Best Python Code Protection Tools in 2025: Top Picks