Installing UiPath CLI

UiPath CLI is distributed on npm as @uipath/cli and installs the uip command globally. It runs on any platform supported by Node.js 18 or later — Windows, macOS, and Linux, on both x64 and ARM64.

Voraussetzungen

• Node.js 18 or later. Node.js ships with npm, which is sufficient to install and run uip.
• Any platform — Windows (x64, ARM64), macOS (x64, ARM64), Linux (x64, ARM64).

Check your Node version:

node --version

If Node.js is older than 18 or not installed, download it from nodejs.org or use a version manager such as nvm (macOS/Linux) or nvm-windows.

Installieren

npm

npm install -g @uipath/cli

pnpm

pnpm add -g @uipath/cli

Hinweis:

Both package managers install the same @uipath/cli package from the public npm registry. Use whichever one your team already has in place.

The installation places the uip executable on your PATH. On Windows the uip.cmd / uip.ps1 launcher lives under %APPDATA%\npm\; on macOS and Linux the uip launcher (a small shim around node ./dist/index.js) lives under the prefix reported by npm config get prefix (commonly /usr/local/bin or ~/.npm-global/bin).

Verify the installation

uip --version

You should see the installed version number (for example, 1.0.0).

uip --help

You should see a list of core commands — login (with the status, tenant list, tenant set subcommands), logout, tools, skills, mcp, completion — followed by the tools that have been installed or registered on your machine.

To confirm where the uip launcher and its tools live:

npm root -g              # directory holding @uipath/cli and installed tools
npm config get prefix    # parent directory whose bin/ folder holds the uip launcher

First command

UiPath CLI ships with only the host and a small set of core commands. No tools are preinstalled. The first time you invoke a command whose prefix matches a tool on the auto-install whitelist, the host downloads and installs that tool from npm automatically.

For example, the first time you run an Orchestrator command, uip installs @uipath/orchestrator-tool:

uip or folders list

Installing @uipath/orchestrator-tool...
✓ Installed @uipath/orchestrator-tool
...

Subsequent uip or ... invocations use the installed tool directly. You can also install tools explicitly — useful on CI runners and restricted networks — with uip tools install:

uip tools install @uipath/orchestrator-tool
uip tools install @uipath/solution-tool

See Tools (plugins) for the full whitelist and Managing tools and skills for day-to-day tool management.

Controlling tool auto-install

Auto-install runs whenever the invoked verb is on the whitelist and the tool is not yet installed. There is no opt-out flag or environment variable — in particular, CI=true does not disable auto-install. On stateless CI runners this means the first command in a build downloads its tool, and later commands in the same job reuse the already-installed copy. That makes the first command slower than subsequent ones unless you pre-install.

To keep CI build times deterministic, pre-install the tools you use as a separate step, so every later uip call finds them already present:

uip tools install @uipath/orchestrator-tool @uipath/solution-tool

Auto-install is a no-op when the tool is already installed, so the pre-install step is the only behavior change you need.

Enable shell completion

UiPath CLI ships tab completion for bash, zsh, fish, and pwsh. Completion is installed from within the CLI itself:

uip completion

In a terminal, uip completion detects your shell from $SHELL / $PSModulePath / platform, prints the target rc file it will modify, and asks for confirmation. Accept the prompt and reopen your shell — uip <TAB> now completes subcommands and options.

For scripted setup, pipe the completion script into your rc file directly:

# zsh
uip completion zsh >> ~/.zshrc

# bash
uip completion bash >> ~/.bashrc

# fish
uip completion fish > ~/.config/fish/completions/uip.fish

# PowerShell
uip completion pwsh >> $PROFILE

Other options:

• uip completion --print — preview the target path and the block that would be written, without modifying the filesystem.
• uip completion --uninstall — remove the managed completion block.

Hinweis:

Dynamic flag-value completion (for example, uip or packages upload --package-name <TAB>) is zsh-only and requires the jq utility on your PATH. Without jq, dynamic candidates are suppressed; static subcommand and option-name completion still works on all four shells.

Warnung:

Re-run completion after every CLI or tool upgrade

The completion script is a static snapshot of the subcommands and option names known at the time uip completion was run. After npm install -g @uipath/cli@<new-version>, uip tools install <new-tool>, or uip tools update, re-run uip completion so newly added commands and flags are indexed:

uip completion              # interactive — refreshes the existing block
uip completion zsh >> ~/.zshrc   # or pipe into the rc file directly

Without a refresh, new verbs (for example, a verb added in a tool MINOR release) will not autocomplete even though they work on the command line.

Platform notes

Windows

Run commands from PowerShell, Windows Terminal, or cmd. If uip is not recognized after installation, open a new terminal window so the updated PATH takes effect, or run:

npm config get prefix

and confirm that the returned directory is on your PATH.

macOS and Linux

Most package managers place the uip executable on the default PATH. If you install npm globals into a user-local directory (as recommended — avoids sudo), make sure that directory is on your PATH. For example, with a ~/.npm-global prefix:

export PATH="$HOME/.npm-global/bin:$PATH"

Add the line to your shell profile (~/.zshrc, ~/.bashrc, etc.) to persist it.

Behind a corporate proxy

UiPath CLI respects standard HTTP proxy environment variables for both the CLI itself and tool auto-installation:

Variable	Zweck
HTTP_PROXY / http_proxy	Proxy for HTTP requests
HTTPS_PROXY / https_proxy	Proxy for HTTPS requests
NO_PROXY / no_proxy	Comma-separated list of hosts that bypass the proxy

Beispiele:

# macOS / Linux
export HTTPS_PROXY=http://proxy.example.com:8080
export NO_PROXY=localhost,127.0.0.1,.internal.corp
uip login

# Windows PowerShell
$env:HTTPS_PROXY = "http://proxy.example.com:8080"
$env:NO_PROXY = "localhost,127.0.0.1,.internal.corp"
uip login

:: Windows cmd
set HTTPS_PROXY=http://proxy.example.com:8080
set NO_PROXY=localhost,127.0.0.1,.internal.corp
uip login

Proxies with basic authentication are supported by including credentials in the URL: http://user:[e-mail]:8080.

Tipp:

The CLI bundles a proxy-aware fetch implementation, so HTTPS_PROXY / HTTP_PROXY are honored without extra configuration on Node.js.

Telemetrie

UiPath CLI sends anonymous usage telemetry to UiPath to help improve the product. No command arguments, file contents, or credentials are transmitted.

Variable	Verhalten
UIPATH_TELEMETRY_DISABLED	Set to 1 or true to opt out.
UIPATH_AI_CONNECTION_STRING	Override the Application Insights connection string — for example, to route telemetry to your own instance.

# Opt out for the current shell
export UIPATH_TELEMETRY_DISABLED=1

# Or just for one command
UIPATH_TELEMETRY_DISABLED=1 uip login

Installing in CI/CD

Install the CLI as a step in your pipeline. Because uip has no tools preinstalled, either let tools auto-install on first use or pre-install them explicitly — the latter is faster on stateless runners because the tool download happens once per step rather than on every command.

GitHub Actions

steps:
  - uses: actions/setup-node@v4
    with:
      node-version: '20'

  - name: Install UiPath CLI
    run: npm install -g @uipath/cli

  - name: Pre-install tools
    run: uip tools install @uipath/orchestrator-tool @uipath/solution-tool

  - name: Authenticate
    run: uip login --client-id env.UIPATH_CLIENT_ID --client-secret env.UIPATH_CLIENT_SECRET
    env:
      UIPATH_CLIENT_ID: ${{ secrets.UIPATH_CLIENT_ID }}
      UIPATH_CLIENT_SECRET: ${{ secrets.UIPATH_CLIENT_SECRET }}

  - name: Run CLI commands
    run: uip or folders list --output json

Azure DevOps

steps:
  - task: NodeTool@0
    inputs:
      versionSpec: '20.x'
    displayName: 'Use Node.js 20'

  - script: npm install -g @uipath/cli
    displayName: 'Install UiPath CLI'

  - script: uip tools install @uipath/orchestrator-tool @uipath/solution-tool
    displayName: 'Pre-install UiPath CLI tools'

  - script: uip login --client-id env.UIPATH_CLIENT_ID --client-secret env.UIPATH_CLIENT_SECRET
    displayName: 'Authenticate'
    env:
      UIPATH_CLIENT_ID: $(UIPATH_CLIENT_ID)
      UIPATH_CLIENT_SECRET: $(UIPATH_CLIENT_SECRET)

Jenkins (declarative pipeline)

stage('Install UiPath CLI') {
  steps {
    sh 'npm install -g @uipath/cli'
    sh 'uip tools install @uipath/orchestrator-tool @uipath/solution-tool'
  }
}

stage('Authenticate') {
  steps {
    withCredentials([
      string(credentialsId: 'UIPATH_CLIENT_ID', variable: 'UIPATH_CLIENT_ID'),
      string(credentialsId: 'UIPATH_CLIENT_SECRET', variable: 'UIPATH_CLIENT_SECRET')
    ]) {
      sh 'uip login --client-id env.UIPATH_CLIENT_ID --client-secret env.UIPATH_CLIENT_SECRET'
    }
  }
}

See CI/CD recipes for full pipeline examples including pack, publish, and test stages.

Tipp:

Cache the npm global directory between builds to avoid reinstalling @uipath/cli and its tools on every run. On GitHub Actions, use actions/cache keyed on the CLI version you pin.

Installing from the GitHub npm registry

A subset of @uipath/* tool packages — currently @uipath/rpa-tool and @uipath/flow-tool — are published to the GitHub npm registry (https://npm.pkg.github.com) rather than to the public npm registry. Before uip tools install can resolve them, configure npm to route the @uipath scope through GitHub's registry.

Create (or update) ~/.npmrc (user-level) or ./.npmrc (project-level) with:

@uipath:registry=https://npm.pkg.github.com
//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}

GITHUB_TOKEN needs at least the read:packages scope; for an unauthenticated pull of a public GitHub package, the token line can be omitted (behavior varies per package — check the repo's visibility).

export GITHUB_TOKEN=<your-pat>
npm install -g @uipath/cli
uip tools install @uipath/rpa-tool

Once configured, uip tools install and uip tools update pick up GitHub-registered packages the same way they pick up public ones.

Hinweis:

The host package @uipath/cli itself is on the public npm registry. Only the tools marked in Release notes as GitHub-registered need the extra .npmrc.

Running without a global install

For ad-hoc use or pipelines that prefer not to install globally, you can run the CLI through npx:

npx -y @uipath/cli <command>

Zum Beispiel:

npx -y @uipath/cli login
npx -y @uipath/cli or folders list

The first invocation downloads the package; subsequent invocations reuse the npm cache.

Upgrades

Reinstall the package with the same command you used to install it, choosing either the latest release or a pinned version:

# latest release
npm install -g @uipath/cli@latest

# pinned version
npm install -g @uipath/cli@1.0.0

The equivalent pnpm command is pnpm add -g @uipath/cli@latest.

Tipp:

Pin an exact version in CI. @uipath/cli follows semantic versioning, but the shape of Data in JSON output is command-specific and may change between MINOR releases (see Versioning and stability). Pinning avoids build-time surprises on pipelines that parse JSON. When you bump, re-validate scripts that depend on specific field names.

See the release notes for what changed between versions.

Upgrading the host does not automatically upgrade installed tools. To update tools:

uip tools update                        # update all installed tools
uip tools update --name <package>       # update a single tool
uip tools update --name <package> --version <version>   # pin to a specific version

By default, each tool version tracks the CLI's MAJOR.MINOR line, so running uip tools update after a CLI upgrade brings every installed tool into step. See Tools (plugins) for the pinning contract.

Deinstallieren

Remove the CLI with the package manager you used to install it:

npm uninstall -g @uipath/cli
# or
pnpm remove -g @uipath/cli

This removes the uip executable and the installed tools.

Remove credentials and data

Uninstalling the package leaves several pieces of on-disk state behind. Clean them up manually when you want a fresh start or need to decommission a machine.

Session credentials

uip login persists the session inside ~/.uipath/ in your home directory by default. When the CLI starts, it walks up from the current directory looking for a .uipath/ folder first — so a project folder can carry its own session without modifying the user's home directory. Check both locations when cleaning up:

# macOS / Linux
rm -rf ~/.uipath

# Windows PowerShell
Remove-Item -Recurse -Force "$env:USERPROFILE\.uipath"

Check each project you worked in for a local .uipath/ as well. See Sessions and credentials for the full layout.

Shell completion

If you ran uip completion, the completion block is still in your shell rc file after uninstall. Remove it before uninstalling @uipath/cli, or clean it up manually from ~/.zshrc, ~/.bashrc, or $PROFILE:

# Before uninstalling, while uip is still available:
uip completion --uninstall

npm global cache

npm keeps a local cache of downloaded tarballs at the path reported by npm config get cache. This does not need to be cleaned for most users; clean it only to recover disk space or to troubleshoot a corrupt download:

npm cache clean --force

Fehlersuche und ‑behebung

uip: command not found after installation

The npm global directory is not on your PATH. Run npm config get prefix to see where npm placed the uip launcher, then add that directory's bin subfolder to your PATH and open a new terminal.

EACCES or permission errors on install

On macOS and Linux, avoid sudo npm install. Configure npm to use a user-local prefix once:

mkdir -p ~/.npm-global
npm config set prefix ~/.npm-global
export PATH="$HOME/.npm-global/bin:$PATH"

Then reinstall: npm install -g @uipath/cli.

Tool auto-install hangs or times out

You may be behind a proxy that blocks npm. Configure HTTPS_PROXY as described in Behind a corporate proxy, or pre-install the tools on a machine with internet access and copy the global node_modules to the target machine.

Node version too old

uip requires Node.js 18 or later. Upgrade Node.js or switch versions with nvm use 20.

See Troubleshooting for more errors and their resolutions.

Nächste Schritte

• Quickstart — log in, list Orchestrator folders, and run a job in five minutes.
• Your first pipeline — pack a project and deploy it from CI.
• Authentication — interactive login, External App client credentials, and environment-variable authentication for CI.
• Using UiPath CLI with coding agents — install skills into Claude Code, Cursor, GitHub Copilot, or Gemini CLI.