What Is PyArmor? How It Works, Pricing, and Free Alternatives (Tested)

PyArmor is a command-line obfuscator for Python made by Dashingsoft. You point it at your scripts and it returns a protected version that runs the same but is deliberately hard to read, decompile, or tamper with. It's been around for years and is the default answer to "how do I stop people reading my Python?" — because, unlike most alternatives, it doesn't just rearrange your source.

The important idea: PyArmor doesn't leave normal Python (or normal bytecode) on disk. It transforms your code into an encrypted payload that only its own native runtime extension can load and execute. That runtime is a compiled C module (pyarmor_runtime.pyd on Windows, .so on Linux/macOS), which is why the result resists the decompilers that make plain .pyc and PyInstaller trivial to reverse — as I've shown in can .pyc files be decompiled and decompiling a PyInstaller exe.

I installed the free trial (pip install pyarmor) and obfuscated this small 490-byte "licensed" script — it has a hard-coded API key and a license check, the two things people most want hidden:

import sys
API_KEY = "sk-lictool-4b7d92e1a0"
LICENSE_CODE = "LT-PRO-2026-5590"

def check_license(code: str) -> bool:
    return code == LICENSE_CODE

def greet(user: str) -> str:
    return f"welcome {user}"

def main():
    code = sys.argv[1] if len(sys.argv) > 1 else ""
    if not check_license(code):
        print("access denied"); return
    print(greet("mithun"))

if __name__ == "__main__":
    main()

INFO     start to generate runtime files
INFO     target platforms {'windows.amd64'}
INFO     write dist\pyarmor_runtime_000000\pyarmor_runtime.pyd
INFO     obfuscating file lictool.py
INFO     write dist\lictool.py
INFO     obfuscate scripts OK

It produced a dist/ folder with two things: my lictool.py (now obfuscated) and a pyarmor_runtime_000000/ package containing a 632 KB native `pyarmor_runtime.pyd`. The obfuscated lictool.py is no longer my code at all — it's a 7,510-byte bootstrap that hands an encrypted byte-string to the runtime:

# Pyarmor 9.2.6 (trial), 000000, non-profits, 2026-08-16
from pyarmor_runtime_000000 import __pyarmor__
__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0b\x00\xa7\r\r\n\x80\x00\x01\x00 ...about 7 KB of encrypted bytes... ')

It still runs exactly like the original — python lictool.py LT-PRO-2026-5590 prints welcome mithun — but your logic now lives inside that encrypted blob, decrypted in memory by the C runtime at execution time.

This is where PyArmor genuinely differs from .pyc/PyInstaller. With a plain PyInstaller build, grep finds your hard-coded secrets in the extracted bytecode in plaintext. With PyArmor, the same search finds nothing — in either the obfuscated .py or the native runtime:

$ grep -c "LT-PRO-2026-5590"    dist/lictool.py
0
$ grep -c "sk-lictool-4b7d92e1a0" dist/pyarmor_runtime_000000/pyarmor_runtime.pyd
0

And because there's no standard .pyc on disk — just an encrypted payload — the usual decompilers (pycdc, uncompyle6) have nothing to work on. That's a real step up: PyArmor is legitimately one of the stronger off-the-shelf ways to protect a Python script.

pip install pyarmor gives you a free trial that doesn't expire — the basic pyarmor gen obfuscation above works with no payment. But the trial deliberately holds back the stronger modes. Its own pyarmor -v spells out the limits:

Pyarmor 9.2.6 (trial), 000000, non-profits

BCC Mode        : No
RFT Mode        : No
CI/CD Mode      : No

Notes
* Can't obfuscate big script and mix str

• No RFT mode — Reform Table renaming (renames functions/classes/variables) is Pro-only.
• No BCC mode — the strongest option, which converts Python functions to C machine code, is Pro-only.
• Big-script and string-mixing limits — the trial refuses to obfuscate large modules or apply string encryption freely.

So the free trial is genuinely useful for a small script, but the headline protection features people buy PyArmor for are behind a license.

PyArmor is a pay-once, perpetual license (except CI) — the version you buy keeps working, though future major versions may need a new purchase. As of August 2026, from the official store:

For most solo developers who want the real protection (BCC/RFT), Pro at $89 is the relevant tier. Prices change, so confirm on PyArmor's official site before buying — and note licensing is per build-device, not per shipped copy.

If you don't want to pay, there's no free tool that exactly matches PyArmor Pro's encrypted-runtime + BCC model. But depending on your threat model, you have real free options:

The honest positioning: our free Python Obfuscator is the fastest no-install, no-cost way to make a script meaningfully harder to read (it renames identifiers and encrypts strings at the AST level and outputs standalone Python with no runtime to ship). It's a lower bar than PyArmor Pro's encrypted runtime, but it's free, browser-based, and adds no .pyd dependency. For a higher bar without paying, compiling with Nuitka or Cython ships actual machine code. We break the whole spectrum down in PyArmor vs Nuitka vs Cython vs Pyobfuscate.

• Use PyArmor (Pro) if you're shipping commercial software where source protection genuinely matters and you want the strongest off-the-shelf option — BCC mode compiling functions to C is a real barrier, and $89 once is cheap versus building it yourself.
• Use the free trial if you just need to protect a small script and can live without RFT/BCC.
• Use a free AST obfuscator like ours if you want to deter casual copying with zero cost, zero install, and no native runtime to bundle — good for scripts, bots, and freelance deliverables.
• Use Nuitka/Cython if you're comfortable with a build step and want native machine code without a per-device license.

Whatever you pick, remember the universal rule the tests keep proving: don't hard-code real secrets in client-side code — obfuscation raises the cost of reading them but the program still has to decrypt them to run. Keep keys server-side (see protecting API keys in Python).