pyobfus: the Python obfuscator

pyobfus is a local-first, AST-based Python obfuscator for Python 3.9–3.15. It obfuscates multi-file projects and packages as a whole: names are renamed consistently across modules and imports are rewritten to match, so Community output is still ordinary .py that runs without pyobfus installed. Keep the mapping file from the build private, and pyobfus --unmap turns a production traceback back into your original names, for you or an AI coding agent. Community is Apache-2.0, has no file or line limits, and requires no trial.

Use the released CLI or MCP workflow to evaluate a delivery: scan, build, run your application checks on the output, and restore a traceback. The changelog and support matrix record maintained compatibility and tested limits. Start custom integration with configuration or a thin wrapper when these interfaces fit your task.

What's new in v0.13.0: Community pre-commit hooks stop pyobfus mapping files and PEM private keys from being committed (pyobfus-no-private-material) and check built output before pushing (pyobfus-check-delivery). They read files locally, print only paths and reasons, and need no licence.

Earlier releases: see the changelog.

Why pyobfus

Related MCP server: MCP Python Toolbox

Quick start

pip install pyobfus

# Check compatibility, preview, then build
pyobfus --check src/
pyobfus src/ -o dist/ --dry-run --json
pyobfus src/ -o dist/ --save-mapping mapping.json --verify-syntax
# --verify-syntax only compiles the output; run your own tests against dist/

# Restore names when a production traceback arrives
pyobfus --unmap --trace error.log --mapping mapping.json

Independent-file directory builds (--no-cross-file) support --save-mapping since 0.9.0. Their version-2 mapping resolves each traceback frame against its own file; names in excerpts and unframed logs stay unchanged. See the debugging guide.

Since 0.7.1, add opt-in --verify-names to check newly unbound globals without execution. Success JSON reports partial coverage explicitly; see name verification for usage and limits. Check the final directory or wheel with pyobfus --check-delivery dist/ --json before shipping.

For framework presets, configuration discovery, packaging and verification, start at the task-oriented documentation.

Minimal example

Input:

def greet(name):
    message = f"Hello, {name}!"
    return message

print(greet("world"))

Run pyobfus input.py -o output.py. Representative Community output:

def I0(I1):
    I2 = f"Hello, {I1}!"
    return I2

print(I0("world"))

Both print Hello, world!. Generated identifiers can differ with input and configuration; verify the exact output with your own tests. Keep a mapping when you need to restore names from a shipped traceback.

Parameter names are preserved by default in every preset. Explicit --no-preserve-param-names or YAML preserve_param_names: false keeps legacy renaming with a warning: keyword calls may raise TypeError or silently bind incorrectly. Rebuild from original source and keep the new mapping with the new artifact; mapping numbers can change and old mappings cannot decode rebuilt output. Cross-file directory builds (the default) still preserve parameters; legacy --no-cross-file directory builds follow the option.

Features at a glance

Community includes name mangling with import rewriting across a project (directories also rename function locals; parameters and methods remain unchanged there; single files also rename methods and preserve parameters by default, see the guide), string and numeric transforms, framework-aware presets, config-aware pre-flight scanning (including coarse hardcoded-secret screening without displaying values), SARIF, structured dry-run, reverse traceback mapping, syntax verification, provenance, reproducible output and verifiable build reports.

Pro builds require an active trial or a registered license. This applies to CLI flags, presets, configuration files, MCP builds, and direct library transforms. Installing the bundled Pro components alone does not activate Pro. See the activation and offline-use guide.

Professional adds four kinds of commercial value:

• Protection strength: AES encryption, control-flow flattening, dead-code injection, anti-debugging, Selective Opacity and sealing.

• Protected assets: import strings, embedded data, Runtime String Vault and protected tracebacks.

• Distribution control: device, expiry, run-count, platform and application-supplied-key policies.

• Accountability: forensic watermarking and buyer-specific builds.

The durable classification rule is documented in the Community / Pro boundary policy.

🔌 Companion MCP server: pyobfus-mcp

Install the MCP server with no API key and no source upload:

uvx pyobfus-mcp
# or: pip install pyobfus-mcp

It exposes structured tools for scanning, configuration, protection, verification, preset explanation, tier recommendations and traceback mapping. See the MCP package guide and its registration in the official MCP Registry.

Agent and editor integrations

• pyobfus-review and pyobfus-protect skills separate read-only review from build-producing work. See skills.

• The VS Code extension provides inline risk diagnostics and traceback reversal; it is also on Open VSX.

• zhurong2020/pyobfus-action@v1 runs scans or verified builds in GitHub Actions with SARIF support.

• The stable JSON CLI includes reason codes and an ai_hint next action.

• Agent-readable project facts are published in llms.txt, while contributor instructions live in AGENTS.md.

All Agent guidance is public and human-auditable. pyobfus does not serve hidden instructions or different facts based on User-Agent.

Configuration

Generate a starting configuration or use a named preset:

pyobfus --init src/
pyobfus src/ -o dist/ --preset django
pyobfus --list-presets

Community presets include safe, balanced, aggressive, fastapi, django, flask, pydantic, click, sqlalchemy and ml. See the documentation home and pyobfus --help for current options. Optional max_files and max_total_loc values are user-selected safety limits at every tier.

How do I debug an obfuscated crash with an AI assistant?

Build with --save-mapping mapping.json, keep that file private, then run:

pyobfus --unmap --trace error.log --mapping mapping.json

The restored identifiers can be read by you or an AI assistant without giving the customer your mapping or original source. --trace-marker can also stamp generated files with the exact recovery command.

Purchase Professional Edition

Pro builds in CI need PYOBFUS_LICENSE_KEY or a registered runner. The secret verifies online without consuming device slots; see CI licensing.

Professional Edition is $45 USD, one time—not a subscription. A five-day trial requires no registration or card:

pyobfus-trial start

The trial is an honor-system convenience control, not a security boundary. Visit the product and purchase page for current payment methods, refund terms and purchase steps. After purchase, use the license activation guide.

Runtime-backed Pro artifacts depend on the separately redistributable, pure-Python pyobfus-runtime package. Target machines do not need the complete proprietary builder or a licence key.

Security and limitations

Obfuscation raises the cost of inspection; it does not make client-side Python irreversible. Runtime-decrypted material can be observed by a determined attacker. Keep credentials and authorization decisions behind environment, secret-manager or server boundaries.

• Threat model

• Support matrix

• Release provenance

• Security policy

Comparison and deployment guides

• Comparison overview

• vs PyArmor

• vs Nuitka

• PyInstaller cookbook

• Compiled-packaging cookbook

• pre-commit hooks (since 0.13.0): block mappings and private keys in commits and check built output before pushing.

• Integration testing

Architecture and development

The product line separates the Apache-2.0 Core, proprietary Pro builder, redistributable runtime, MCP package, editor extension and GitHub Action. See:

• Project structure

• Contributing guide

• Developer instructions

• Changelog

Community and citation

Use GitHub Issues for bugs and Discussions for questions and ideas. Citation metadata is in CITATION.cff, with archival DOI 10.5281/zenodo.20846053.

Core is Apache-2.0; Professional implementation is proprietary. See LICENSE-NOTICE.md. Selected Professional Edition mechanisms are patent pending (CN 202610712171X, not yet granted).