UiPath Platform — uip CLI Assistant

Comprehensive guide for UiPath Cloud / Orchestrator / Studio Web / Integration Service, end-to-end via the uip CLI. For uip solution lifecycle and PDD/SDD authoring, load uipath-solution.

Use the CLI. Don’t roll your own REST.

Always reach for uip CLI commands first. The CLI covers auth, Orchestrator (folders, processes, jobs, machines, users, roles, sessions, calendars, settings, audit logs, credential stores, feeds, attachments), resources (assets, queues, queue items, storage buckets, bucket files, libraries, webhooks, triggers), Integration Service (connectors, connections, activities, IS triggers), traces, and licensing end-to-end.

Hand-rolling HTTP calls — reading ~/.uipath/.auth and POSTing to /odata/... or /orchestrator_/... — almost always misses something the CLI gets right: the X-UIPATH-OrganizationUnitId folder header, OData filter shape (Key eq '...' with escaped single quotes), pagination envelope, retry semantics, validation error shape, or Result/Code/Data output contract. Reach for raw REST only after you’ve searched references/uip-commands.md for your task and confirmed no uip command covers it. The CLI is the source of truth.

If you find yourself about to curl https://cloud.uipath.com/... — stop. Search the command index first. Examples of what people often miss:

• “upload a file to a storage bucket” → uip resource bucket-files upload (NOT a PUT /buckets/.../signedUrl dance)
• “create an asset” → uip resource assets create (NOT a POST /odata/Assets)
• “start a job for a process” → uip or jobs start <process-key> (NOT POST /odata/Jobs/UiPath.Server.Configuration.OData.StartJobs)
• “configure an Integration Service connection” → uip is connections create <connector-key> (NOT a hand-rolled OAuth flow)

When to Use This Skill

Load this skill BEFORE writing any code that talks to UiPath. Specific triggers:

• Auth & tenant: login, logout, switch tenant, ~/.uipath/.auth, OAuth token, organization
• Orchestrator core: folders (list/get/create/edit/move/delete/runtimes), processes/releases, jobs (start/stop/logs/traces/healing-data), packages (upload/download/versions), machines, users / roles / sessions (incl. DirectoryUser/DirectoryGroup/DirectoryRobot/DirectoryExternalApplication), licenses, calendars, settings, audit logs, credential stores, feeds, attachments
• Resources (Orchestrator-scoped): assets (text/integer/bool/credential), queues + queue items, storage buckets + bucket files (upload/download/get-download-url/get-upload-url), libraries (.nupkg), webhooks (HMAC signing), triggers (time/queue/api)
• Integration Service: connectors, connections (OAuth flow), activities, IS triggers, agent-workflow reference resolution
• LLM Gateway — BYO product configurations: uip llm-configuration byo-connections (list / get / create / update / delete / list-product-configs). Register tenant-owned OpenAI / Azure OpenAI / AWS Bedrock / Google Vertex / Anthropic / OpenAI-compatible keys against UiPath product features (agents, agenthub, jarvis, IXP, agent builder, ECS). Two input shapes: single-mapping (for AnyModelWithOwnAdditions features) and repeated --mapping (required for AllModels / AnyModel). Server-side validation is mandatory.
• LLM Gateway — diagnose a failing BYO config: re-probe the underlying IS connection with byo-connections get <id> --force-refresh, force a fresh server-side probe with an idempotent update, audit the tenant with list --include-connection-details filtered on connectionState != Enabled, check catalog drift with list-product-configs, and cross-reference trace evidence with uip traces spans get <trace-id>. The gateway does not expose per-request invocation logs via CLI — diagnosis is current-state + trace evidence only. See references/llmgateway/byo-connections.md § Diagnostics. For tenant-wide AI Trust Layer policy that may be overriding routing, see uipath-governance.
• Traces: uip traces spans get [trace-id] (LLM/agentic execution observability)
• Platform licensing: tenant license allocations, user/group bundle assignments, consumables reporting (uip platform tenants licenses, users licenses, groups rules, licenses consumables)
• CLI tooling itself: uip tools list/search/install, uip mcp serve

For uip solution lifecycle (init / pack / publish / deploy / activate / upload) and CI/CD pipelines that build and deploy UiPath solutions, load uipath-solution.

Auth token location

The CLI stores credentials at ~/.uipath/.auth after login:

UIPATH_URL=https://alpha.uipath.com
UIPATH_ORG_NAME=my_org
UIPATH_TENANT_NAME=my_tenant
UIPATH_ACCESS_TOKEN=eyJ...
UIPATH_ORGANIZATION_ID=...
UIPATH_TENANT_ID=...

This token can be reused for direct Orchestrator REST API calls when CLI commands don’t cover a use case.

Quick Start

Step 1 — Authenticate

Before interacting with Orchestrator, solutions, or Integration Service, the user must be logged in.

Interactive login (browser OAuth2):

uip login --output json

For a custom authority (e.g., alpha.uipath.com):

uip login --authority "https://alpha.uipath.com/identity_" --it --output json

For non-interactive (CI/CD) scenarios, use client credentials:

uip login --client-id "<ID>" --client-secret "<SECRET>" --tenant "<TENANT>" --output json

Check login status:

uip login status --output json

Step 2 — Select a Tenant

List available tenants and set the active one:

uip login tenant list --output json
uip login tenant set "<TENANT_NAME>" --output json

Step 3 — Explore Orchestrator

List folders to orient yourself:

uip or folders list --output json

Step 4 — Work with Orchestrator Resources

Choose the appropriate operation from the Task Navigation table below. For uip solution ops, load uipath-solution.

Task Navigation

Resolving UiPath Studio

Some operations (creating projects, validating, running workflows, packing) require UiPath Studio. When Studio is needed:

1. Check for a running instance first:

   rpa-tool list-instances --output json
   

2. If no instance is running, try the standard install location:

   rpa-tool start-studio --output json
   

3. If that fails (version too old, not found, etc.) — ASK THE USER where their Studio build is located. Do NOT search the entire filesystem. Common locations include:
   • C:\Program Files\UiPath\Studio
   • A dev build directory (e.g., dev4/Studio/Output/bin/Debug)
   • A custom install path
4. Once you have the path, pass it explicitly:

   rpa-tool start-studio --studio-dir "<STUDIO_DIR>" --output json
   

Never spend time searching for Studio automatically. If the default doesn’t work, ask immediately — the user knows where their build is.

Key Concepts

UiPath Platform Hierarchy

Organization
  └── Tenant(s)
        └── Folder(s)              ← Orchestrator folders (logical containers)
              ├── Processes         ← Published automation packages
              ├── Assets            ← Key-value configuration (Text, Bool, Integer, Credential, Secret)
              ├── Queues            ← Work item queues for distributed processing
              ├── Jobs              ← Running/completed process executions
              ├── Triggers          ← Event-based or queue-based job triggers
              ├── Schedules         ← Time-based job scheduling (cron)
              ├── Storage Buckets   ← File storage for automation data
              ├── Machines          ← Robot execution environments
              └── Robots            ← Attended/Unattended execution agents

Robot Types

Folder Types

Asset Types

CLI Overview

The UiPath CLI (uip) is a unified command-line tool for interacting with the UiPath platform:

Global Options

Every uip command accepts:

Always use --output json when calling uip commands programmatically. JSON is compact and machine-readable.

To narrow list results, use the noun’s own filter flag (--state Faulted, --type Text, --status New, --name, --process-name, --search). The backend filters before sending; pagination stays correct. Per-noun flags: references/uip-commands.md. Never list-everything-then-filter-mentally.

Use --output-filter (JMESPath) for output reshaping or for fields with no server-side flag — e.g., --output-filter "Data[].{id: id, name: name}", or filtering by a derived/computed value. Don’t reach for it when the server already has a filter for that attribute.

Deployment Notes

• Starting jobs requires runtimes. If you get error 2818 “no runtimes configured”, the target folder needs machine templates with Unattended/Development runtimes assigned.
• For uip solution pack / publish / deploy / activate flows, load uipath-solution. This skill owns the auth and Orchestrator surface those flows depend on; the solution skill owns the lifecycle commands.
• Fallback: direct REST API. When CLI tools don’t support an operation, use the Orchestrator REST API with the access token from ~/.uipath/.auth. See references/orchestrator/orchestrator.md - REST API.

Orchestrator REST API (Fallback)

When CLI commands are insufficient, use the Orchestrator REST API directly with the stored access token:

source ~/.uipath/.auth

# Upload a .nupkg package
curl -X POST "${UIPATH_URL}/${UIPATH_ORG_NAME}/${UIPATH_TENANT_NAME}/orchestrator_/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage" \
  -H "Authorization: Bearer ${UIPATH_ACCESS_TOKEN}" \
  -H "X-UIPATH-OrganizationUnitId: <FOLDER_ID>" \
  -F "file=@./MyProject.1.0.0.nupkg"

# Create a process (release) from an uploaded package
curl -X POST "${UIPATH_URL}/${UIPATH_ORG_NAME}/${UIPATH_TENANT_NAME}/orchestrator_/odata/Releases" \
  -H "Authorization: Bearer ${UIPATH_ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -H "X-UIPATH-OrganizationUnitId: <FOLDER_ID>" \
  -d '{"Name":"MyProcess","ProcessKey":"MyProject","ProcessVersion":"1.0.0"}'

# Start a job
curl -X POST "${UIPATH_URL}/${UIPATH_ORG_NAME}/${UIPATH_TENANT_NAME}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs" \
  -H "Authorization: Bearer ${UIPATH_ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -H "X-UIPATH-OrganizationUnitId: <FOLDER_ID>" \
  -d '{"startInfo":{"ReleaseKey":"<RELEASE_KEY>","Strategy":"ModernJobsCount","JobsCount":1,"RuntimeType":"Unattended","InputArguments":"{}"}}'

The X-UIPATH-OrganizationUnitId header is the folder ID (get it from uip or folders list).

References

• CLI Command Reference — Every uip command with workflow links
• Orchestrator — Concepts, folders, jobs, processes, machines, users
• Resources — Assets, queues, buckets, triggers, libraries, webhooks
• Solutions — Solution lifecycle (uip solution init/pack/publish/deploy/activate) and PDD/SDD authoring
• Traces — Spans — LLM execution trace observability
• Traces — Feedback — Annotate traces with sentiment and comments
• Integration Service — Connectors, connections, activities, resources
• LLM Gateway — BYO Connections — Register tenant-owned LLM keys against UiPath products
• Licensing — Tenant allocations, user/group bundles, consumables reporting
• Coded Workflows — Building coded automation projects

Trouble? If something didn’t work as expected, use /uipath-feedback to send a report.