How to Install ComfyUI Manager: A Setup Guide

A ComfyUI workflow stops at missing custom nodes before generating anything. Here is how to install comfyui manager for that situation: Desktop already includes it; current Portable and manual installations need dependencies and a launch flag. The Git-clone method is now a legacy option. Official installation guide.

Choose your installation path

Your setup	Action
ComfyUI Desktop	Use the included Manager.
Windows Portable	Install dependencies with embedded Python; enable Manager.
Manual installation	Use ComfyUI’s existing Python environment; enable Manager.
Deliberately retained legacy installation	Install Manager under custom_nodes.

Back up your working installation before changing dependencies. ComfyUI’s update documentation specifically warns that dependency reinstalls can break custom nodes or replace manually configured packages. Update guidance.

Windows Portable: install dependencies and enable Manager

Stop ComfyUI. Open Command Prompt in ComfyUI_windows_portable, the directory containing python_embeded. That spelling is intentional: Portable bundles its own Python. Portable layout.

Run the dependency installation, then start ComfyUI:

.\python_embeded\python.exe -m pip install -r ComfyUI\manager_requirements.txt
.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --enable-manager

These are the documented Portable commands. For subsequent launches, append --enable-manager to the Python command in your usual launch .bat file, preserving its existing GPU or CPU arguments.

Open the local address printed in the console and keep that console running. Closing it stops the server. Portable startup behavior.

Manual installation: Linux, macOS and Windows

Open a terminal in the ComfyUI directory containing main.py. Activate the environment that already runs ComfyUI. For a Linux/macOS environment named venv:

source venv/bin/activate
python -m pip install -r manager_requirements.txt
python main.py --enable-manager

On Windows Command Prompt, replace the activation line with venv\Scripts\activate.bat. Substitute your actual environment name. The requirements file and launch flag follow the ComfyUI repository’s Manager setup; keep the flag in your normal launcher.

Legacy installation with Git

Use this branch only when maintaining a legacy setup. With Git installed and ComfyUI’s environment active, run from the ComfyUI root:

git clone https://github.com/Comfy-Org/ComfyUI-Manager custom_nodes/comfyui-manager
python -m pip install -r custom_nodes/comfyui-manager/requirements.txt

Restart ComfyUI. The expected location is ComfyUI/custom_nodes/comfyui-manager. Avoid nested Manager directories and ZIP folders ending in -main, which the project warns can break update recognition or cause duplicates. Manager repository.

For legacy Portable, run the clone from its ComfyUI directory, then return to the portable root for dependencies:

.\python_embeded\python.exe -m pip install -r ComfyUI\custom_nodes\comfyui-manager\requirements.txt

Using the embedded interpreter follows ComfyUI’s custom-node dependency instructions. Restart afterward.

Verify Manager and fix missing menus

Load your workflow. In the new interface, a missing-node prompt offers Open Manager. Inspect the package details, select the required version, and install it. The new interface searches registry packages; an absent Git-URL installer is expected. New UI guide.

Restart ComfyUI, refresh the browser, and inspect startup output for import failed. Then execute the workflow and inspect its saved output. Dependency installation belongs in the environment running ComfyUI, so a successful system-Python installation does not establish that the node can import. Custom-node verification.

If the graph loads but fails partway through execution, that is usually a memory ceiling rather than a Manager problem: see ComfyUI out-of-memory errors, causes and fixes.

Missing checkpoints are a separate problem: place the workflow’s required model files in the appropriate model directories. Model installation.

For a missing Manager interface:

• Check the launcher. Include --enable-manager; --disable-manager-ui hides the interface and endpoints. Launch options.
• Check the working directory and core. If manager_requirements.txt is absent, confirm you are beside main.py; an older installation may need the documented update procedure. Update core dependencies alongside core code. Update instructions.
• Check which UI the tutorial shows. For the classic interface on a current pip installation, launch with --enable-manager --enable-manager-legacy-ui. UI selection.

The metric that matters

For a shared worker, use golden-set workflow success ratio:

successful validation cases / all validation cases attempted

Define success as producing the expected output artifact and passing its checks. Finalize timeouts as failures. This proposed installation check applies the Workbook’s good-events/total-events approach: a visible Manager button says less about usable output. Implementing SLOs.

Wiring it up

For automated validation, add this custom metric to your existing Python runner with prometheus-client installed and a Prometheus exporter configured. Call record_result once per finalized case, including rejected submissions and timeouts. Counter API.

from prometheus_client import Counter

checks = Counter(
    "comfyui_workflow_checks_total",
    "Finalized workflow validation cases",
    ["result"],
)
for result in ("success", "failure"):
    checks.labels(result=result)

def record_result(output_valid: bool) -> None:
    result = "success" if output_valid else "failure"
    checks.labels(result=result).inc()

Expose this through the runner’s exporter; Manager does not create this metric. For broader dashboard design, see SentryML’s production monitoring coverage.

What you’ll see

Plot successful cases divided by total cases for each completed validation suite. Healthy: the same golden set passes before and after installation. Bad: failures appear after a package change, even though Manager opens. Investigate the failing node’s startup and execution logs before changing unrelated packages.

Caveats

Run comparisons with the same models, inputs and batch size. A repeated, unchanged ComfyUI graph can reuse cached execution; restart between comparisons so the check exercises the installation. Execution caching.

Keep validation workloads bounded: generation consumes worker capacity. Use pass/fail for a small acceptance suite; reserve p99 latency for a larger performance evaluation. Treat missing observations as missing data.

Keep prompts, filenames and user IDs out of metric labels: unbounded values multiply time series and can expose private input. Label guidance. Review node authors and dependencies before installation; ComfyUI explicitly warns about malicious custom nodes. Installation precautions.