# Configuration files > Configuration files for UiPath Robot, including UiPath.config and proxy.json, system environment variables, and instructions for restarting components after changes. ## Restarting robot components Once you edit configuration files, you need to restart the relevant Robot components for changes to take effect. The following list summarizes how to restart several components, based on the Robot installation mode. Remember to save any ongoing work before you restart to avoid losing any unsaved progress. * **Robot Service** + Service Mode installation 1. Open **Task Manager** > **Services**. 2. Look for the `UiRobotSvc` service, named **UiPath Robot**. 3. Open the context menu for the service and select **Restart**. + User Mode installation - Quit, then relaunch the Assistant, or: 1. Open **Task Manager** > **Details**. 2. Select the `UiPath.Service.UserHost.exe` process. 3. Select **End task**. * **UiPath RobotJS ServiceHost** - Service Mode installations with the JavaScript add-on 1. Open **Task Manager** > **Services**. 2. Look for the `UiPath RobotJS Service` service. 3. Open the context menu for the service and select **Restart**. * **UiPath Assistant** 1. In Assistant, select **Preferences**, then **Quit**. 2. Relaunch the Assistant. * **Widgets** - Restart the Assistant, or: 1. Open the context menu for the Assistant icon in the taskbar. 2. Select **Reload Widgets** ## UiPath.config The `UiPath.config` file contains essential configuration parameters for the Robot. As an admin, you can customize the behavior of your robots by editing the list of parameters in the config file. :::note Each environment might need specific notices, so UiPath allows you to apply different configurations based on the current environment of the robot, whether it's Development, Staging, or Production. Always be careful when editing this file, as inaccurate configuration may cause application issues. ::: :::important Starting with Robot 2025.10, proxy settings are configured in `proxy.json`, not in `UiPath.config`. For details, see [proxy.json](#proxyjson). ::: ### Accessing the file When you install your Robot, the system creates the `UiPath.config` file in the Robot installation folder. To access it, navigate to `%ProgramFiles%\UiPathPlatform\Robot\\UiPath.config` for a per-machine installation, or `%LocalAppData%\Programs\UiPathPlatform\Robot\\UiPath.config` for a per-user installation. On update, the UiPath Platform Installer copies your `UiPath.config` and `NuGet.config` to the new version folder, so your edits are kept. It then resets `Telemetry.Enabled`, `SkipHttpConfigurationSources` and `DisableSecureXaml` in `UiPath.config` (and `DefaultServiceUrl` when `SERVICE_URL` is set) to the values of its installation parameters, so set those through the [installer parameters](https://docs.uipath.com/robot/standalone/2026.10/admin-guide/windows-installations#robot-options). It also sets `signatureValidationMode` in `NuGet.config` from `ENFORCE_SIGNED_EXECUTION` and removes the `trustedSigners` node unless `ENFORCE_SIGNED_EXECUTION` is `true`. ### Customizable settings The `UiPath.config` file consist of the following parameters: * In the `connectionSettings` config section + `DefaultServiceUrl` (string) - Sets the default address the Robot uses to connect to Orchestrator. Example: ``` string DefaultServiceUrl = "https://cloud.uipath.com" ``` + `AutoSignIn` (bool) - Enables the auto sign-in feature for Assistant. Default value is `false`. Example: ``` bool AutoSignIn = true. ``` + `EnforceDefaultServiceUrl` (bool) - Enforces the address provided as `DefaultServiceUrl` to all users. Default value is `false`. Has no effect in Service Mode. Example: ``` bool EnforceDefaultServiceUrl = true. ``` * In the `communicationSettings` config section + `MaxMessageSizeInMegabytes` (byte) - Sets the maximum size of a message the system can send or receive, in MB. Default value is `10`. This is used to prevent overload or process crashes due to handling messages too large. Example: ``` byte MaxMessageSizeInMegabytes = 10; ``` + `InstallPackageTimeout` (TimeSpan) - Sets the time limit for package installations. Default value is 20 minutes. If a package installation takes longer than the defined time, the system aborts the installation. Example: ``` TimeSpan InstallPackageTimeout = TimeSpan.FromMinutes(20); ``` + `RequestTimeout` (TimeSpan) - Defines how long the system waits for a communication response. Default value is 40 seconds. If the system does not receive a response in the set period, it stops and moves forward. This prevents system hang-ups. Example: ``` TimeSpan RequestTimeout = TimeSpan.FromSeconds(40); ``` * In the `packageSettings` config section + `PackagesInstallationFolder` (string) - Sets the default directory where packages are installed. Default value is `%UserProfile%\.nuget\packages`. In Service Mode, the path is expanded for the user that runs each job. + `SkipHttpConfigurationSources` (bool) - Enables the system to ignore package sources configured with an HTTP or HTTPS URL, such as NuGet feeds. Default value is `false`. This means the system does not retrieve packages from these sources, which is useful when the sources are not reliable or secure. + `DisableSecureXaml` (bool) - Allows the Robot to run potentially unsafe workflows. Default value is `false`. + `DirectDownload` (bool) - Stops the Robot from writing downloaded packages to the shared NuGet `http-cache` disk cache. The Robot still reads files that are already in the cache, and downloads the others every time it needs them. Default value is `false`. + `NoCache` (bool) - Stops the Robot from reading or writing the shared NuGet `http-cache`. The Robot uses a temporary folder that it discards instead. Unlike `DirectDownload`, the in-memory download cache still applies, so each package is downloaded once per restore. Default value is `false`. + `PackageSaveWithoutNupkg` (bool) - Allows saving the packages without the `.nupkg` file. Default value is `false`. This is helpful to reduce the download size. * In the `analyticsSettings` config section + `Telemetry.Enabled` (bool) - Allows UiPath to collect and send usage data for analysis. Default value is `true`. The UiPath Platform Installer sets it from its own telemetry setting when it installs or updates the Robot. * In the `robotCacheSettings` config section + `SessionCacheDuration` (TimeSpan) - Defines how long the data from a specific session should be retained in the cache before being discarded. Default value is 30 seconds. This is useful for reusing data such as variable values or details of operations, instead of recreating or refetching it. Example: ``` TimeSpan SessionCacheDuration = TimeSpan.FromSeconds(30); ``` + `GetResourceUrlCacheDuration` (TimeSpan) - Defines how long the URLs for resources, such as APIs or webpages, are stored in cache. Default value is one (1) hour. This is useful for optimizing performance in scenarios where your robots need to access certain resources regularly. Example: ``` TimeSpan GetResourceUrlCacheDuration = TimeSpan.FromHours(1); ``` * In the `robotJsSettings` config section + `ListenerPort` (int) - Sets the port number on which the Robot.js listens for incoming connections. Default value is `2323`. This allows the robot service to interact with web applications running on local or remote servers. Example: ``` int ListenerPort = 2323; ``` + `TokenExpiryInDays` (int) - Sets the validity period, in days, of the token that the robot service issues to a web application after the user gives consent. Default value is 30 days. Example: ``` int TokenExpiryInDays = 30; ``` + `AllowUrlList` (string) - Sets the web origins (the browser `Origin` header) whose RobotJS consent dialog the Robot accepts automatically. Separate entries with semicolons. The default list is `https://cloud.uipath.com`, `https://staging.uipath.com`, `https://alpha.uipath.com`, `https://govcloud.uipath.us` and `https://alpha.gov.uipath-dev.com`. Setting this key replaces the default list. To add origins without replacing it, use the `UIPATH_ROBOTJS_ALLOWLIST` [system variable](#uipath-robot-system-variables). Example: ``` string AllowUrlList = "https://cloud.uipath.com;https://mydomain.com"; ``` :::important * Back up the original `UiPath.config` file before you change it, so you can restore the original settings. * To apply the updates made to the `UiPath.config` file, restart the UiPath service or the system. * Local settings in the `UiPath.config` file take precedence over settings configured in Orchestrator. ::: You can encrypt sensitive data in the `UiPath.config` file for additional security. ## UiPath Robot system variables Further custom behavior can be configured through system environment variables. :::important After modifying any of the system variables, restart the Robot Service. ::: The following list summarizes the most common use cases: * `UIPATH_SESSION_TIMEOUT` - Changes the default 60-second timeout for creating an interactive session. Adjust this value to adapt the Robot behavior based on the performance and load times of the system it interacts with. Example: ``` UIPATH_SESSION_TIMEOUT=75 ``` * `UIPATH_PIP_SESSION_TIMEOUT` - Changes the default 180-second timeout for starting a process in a Robot session. Example: ``` UIPATH_PIP_SESSION_TIMEOUT=60 ``` * `UIPATH_LANGUAGE` - Sets the language the Robot operates in. The value is a culture code, not the language name. The supported codes are `en`, `fr`, `de`, `es`, `es-MX`, `pt`, `pt-BR`, `ja`, `ko`, `ru`, `tr`, `ro`, `zh-CN` and `zh-TW`. The Robot ignores an unsupported value, such as `French`, and falls back to the next source. The order of precedence is: 1. `UIPATH_LANGUAGE` user environment variable 2. `UIPATH_LANGUAGE` machine environment variable 3. `UIPATH_LANGUAGE` process environment variable 4. Current thread UI culture, if supported 5. Default UiPath language (English) Example: ``` UIPATH_LANGUAGE=fr ``` * `UIPATH_HEADLESS_WITH_USER` - Uses the credentials of a specific user, which was previously configured in Orchestrator. Example: ``` UIPATH_HEADLESS_WITH_USER=True ``` * `UIPATH_PRE_LOADED_EXECUTOR` - By default, a preloaded executor is launched when the Robot starts. To change this behavior and launch the preloaded executor only when the first process runs, set this variable to `None`. Example: ``` UIPATH_PRE_LOADED_EXECUTOR=None ``` * `UIPATH_DISABLE_PRE_LOADED_EXECUTOR` - Disables the preloaded executor feature. Example: ``` UIPATH_DISABLE_PRE_LOADED_EXECUTOR=True ``` * `UIPATH_ROBOTJS_ALLOWLIST` - Automatically accepts the robot consent dialog, when establishing the connection between the Robot JS SDK and the Robot Executor. The value is a list of origins separated by semicolons. Each origin includes the scheme, for example `https://myapp.contoso.com`. Add the port only if it is not the default (`80` or `443`). The Robot also accepts the origins in the `AllowUrlList` key of the `robotJsSettings` section of `UiPath.config`. Example: ``` UIPATH_ROBOTJS_ALLOWLIST=https://cloud.uipath.com;https://mydomain.com ``` * `UIPATH_DNS_MACHINENAME` - Allows using the DNS host name for Localhost when creating RDP sessions. To execute unattended jobs in environments with Kerberos authentication for RDP, set this value to True. Example: ``` UIPATH_DNS_MACHINENAME=True ``` * `NUGET_FALLBACK_PACKAGES` - Configures the paths to fallback packages folders. Use semicolons to separate multiple paths. In the absence of this variable, the Robot searches for fallback packages folders in the `Nuget.config` file. * `NUGET_SCRATCH` - Allows multiple User Mode robots on the same machine to share a local path for storing packages. The value must be a path different to the Nuget installation folder, and it acts as a temporary folder for NuGet. :::note Only the `NUGET_SCRATCH` variable should use the configured temporary folder. ::: Example: ``` NUGET_SCRATCH=C:\NuGetTempFolder ``` * `UIPATH_PRESERVE_CREDENTIALS_CASE` - Preserves the original casing of logging credentials (domain\username). Example: ``` UIPATH_PRESERVE_CREDENTIALS_CASE = True ``` * `UIPATH_SESSION_BEHAVIOR` - Configures the way the session restore behaves after a job completes. The following options are available: + `TryReuseAndRestoreSession`—Default option. Attempts to reuse the session and restore it to its previous state after a job completes. If there is no initial session to reuse, it logs off on restore. + `ForceNew`—Creates a completely new session, regardless of the previous session state. Always logs off on restore. + `LeaveSessionActive`—Prevents restoration of the initial session state. + `LeaveSessionDisconnected`—Always disconnects the session on restore. Example: ``` UIPATH_SESSION_BEHAVIOR = LeaveSessionDisconnected ``` * `UIPATH_HTTP_CONNECTION_LIFETIME` - Defines how long the connection to Orchestrator remains open before it is closed and refreshed. Default duration is 30 minutes, but to adjust this value, use value in seconds. Example: ``` // to set 10 minutes UIPATH_HTTP_CONNECTION_LIFETIME = 600 ``` * `UIPATH_FILE_LOG_LEVEL` - Defines the Execution log level used in the local file. This is different than the log level used for Orchestrator. The following options are available: + Verbose + Trace + Information + Warning + Error + Critical + Off Example: ``` // to set verbose level locally UIPATH_FILE_LOG_LEVEL = Verbose ``` * `UIPATH_EXECUTOR_STARTUP_DELAY` - Defines the time in seconds to wait between session creation and Executor startup. This is used when your infrastructure needs to load some services (VPN, security) before the execution of your automation starts. Example: ``` // to set the delay to 5 seconds UIPATH_EXECUTOR_STARTUP_DELAY = 5 ``` * `UIPATH_MEDIUMPLUS_EXECUTOR` - Launches the Robot Executor at the Medium+ integrity level so automations can interact with windows that require higher privileges, such as the Windows CredentialBroker dialog during RDP credential entry. Set it to `1` to enable it. Requires Windows with User Account Control (UAC) enabled. For more information, see [Medium+ integrity elevation](robot-executor.md#medium-integrity-elevation). Example: ``` UIPATH_MEDIUMPLUS_EXECUTOR=1 ``` * `UIPATH_MEDIUMPLUS_INVOKE` - Lets the **Invoke Workflow File** and **Invoke Process** activities run at the Medium+ integrity level on a per-invocation basis. Both conditions are required to elevate: this variable must be enabled **and** the activity must request elevation (its elevation option enabled) — the variable alone has no effect. Set this machine (system) environment variable to `1` to enable it. Requires Windows with User Account Control (UAC) enabled. For more information, see [Medium+ integrity elevation](robot-executor.md#medium-integrity-elevation). Example: ``` UIPATH_MEDIUMPLUS_INVOKE=1 ``` * `UIPATH_APPLY_SERVICE_PROXY` - Makes Robot processes take their proxy from the machine-level `proxy.json` file instead of the proxy configuration of the account running them. Intended for unattended robots whose service account has no user profile to hold a proxy configuration. The per-user proxy credentials are not read, so `proxy.json` must contain them if your proxy requires basic authentication. The Robot Service is not affected, because it always applies `proxy.json`. For more information, see [Using the machine-level proxy for all Robot processes](https://docs.uipath.com/robot/standalone/2026.10/admin-guide/redirecting-unattended-robots-through-a-proxy-server#using-the-machine-level-proxy-for-all-robot-processes). Example: ``` UIPATH_APPLY_SERVICE_PROXY=True ``` * `UIPATH_VERBOSE_LOG_LIMIT` - Limits the number of Verbose logs per Executor process. The default value is `10000`. Once the limit is reached, the Robot logs a warning and drops future Verbose logs. Values of `0` or lower are ignored and the default is used instead. Only the logs that the Robot produces while running activities count toward the limit; messages that the automation logs itself are not affected. A workflow invoked in isolation runs in its own Executor process, so it has its own limit. Example: ``` UIPATH_VERBOSE_LOG_LIMIT=5000 ``` ## proxy.json The `proxy.json` file stores proxy configuration for the Robot Service when running in service mode. Available starting with Robot 2025.10, it replaces proxy settings that were previously maintained in `UiPath.config`. :::important Starting with Robot 2025.10, proxy settings are configured in `proxy.json`. ::: ### Accessing the file **File location:** `%ProgramData%\UiPath\Shared\proxy.json` :::note If you upgrade from an earlier version and already have proxy settings configured, the system automatically migrates your existing settings to `proxy.json`. ::: After editing `proxy.json`, restart the Robot Service or the device for the changes to take effect. :::note The Robot ignores a `proxy.json` file that is not owned by the built-in Administrators group or the local system account. The Robot Service moves such a file aside as `proxy.json.old`. ::: ### Parameters The following parameters are supported. If both `ScriptAddress` and `ProxyAddress` are present in the same file, `ScriptAddress` takes precedence. | Parameter | Type | Description | |-----------|------|-------------| | `ScriptAddress` | String | URL of the proxy auto-configuration (PAC) script. When present, takes precedence over `ProxyAddress`. Example: `http://proxy.address/proxy.pac` | | `ProxyAddress` | String | Address and port of the proxy server. Example: `http://proxy.address:1234/` | | `BypassLocalAddresses` | Boolean | When `true`, local addresses bypass the proxy server. | | `BypassList` | String | Semicolon-separated list of regular expression patterns identifying hosts that bypass the proxy. Use `\\` to escape special regex characters. Example: `server\\.domain\\.local$;192\\.168\\.\\d{1,3}\\.\\d{1,3}` | | `UserName` | String | Username for basic proxy authentication. | | `Password` | String | Password for basic proxy authentication. | | `Domain` | String | Domain for basic proxy authentication. | ### Example configurations For step-by-step configuration instructions, see [Redirecting robots through a proxy server](redirecting-unattended-robots-through-a-proxy-server.md). #### PAC script ```json { "ScriptAddress": "http://proxy.address/proxy.pac" } ``` #### Proxy address with basic authentication ```json { "ProxyAddress": "http://proxy.address:1234/", "BypassLocalAddresses": true, "BypassList": "server\\.domain\\.local$;www.example.com;192\\.168\\.\\d{1,3}\\.\\d{1,3}", "UserName": "myUser", "Password": "", "Domain": "myDomain" } ```