> ## Documentation Index
> Fetch the complete documentation index at: https://launchdarkly.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Web proxy configuration
This topic explains how to configure an SDK to connect to LaunchDarkly through a web proxy. This feature is available for client-side and server-side SDKs.
Connecting to LaunchDarkly through a web proxy is not related to using the Relay Proxy. To learn about the Relay Proxy, read [The Relay Proxy](/docs/sdk/relay-proxy).
## Connecting though a web proxy
If your organization requires that you use a web proxy to connect to external resources, you must configure your LaunchDarkly SDKs to connect through the proxy instead of connecting to LaunchDarkly directly.
Some proxies require authentication with a username and password, or with custom headers. Instructions on how to configure the SDK to send these parameters are in the SDK-specific sections.
In the following examples, the web proxy's hostname is "my-proxy-host" and it uses port 8080. Substitute the appropriate values for your proxy. Details about each SDK's configuration are available in the SDK-specific sections below:
* [Client-side SDKs](#client-side-sdks)
* [Server-side SDKs](#server-side-sdks)
> [!NOTE]
>
> **Using a web proxy with mobile SDKs**
>
> Android, Flutter, iOS, and React Native support using a web proxy through their device operating systems (OS). You can use their onboard OS settings to configure a web proxy.
## Client-side SDKs
This feature is available in the following client-side SDKs:
* [.NET (client-side)](#net-client-side)
* [C++ (client-side)](#c++-client-side)
### .NET (client-side)
> **Expand .NET (client-side) code sample**
>
> To configure the client-side .NET SDK to connect to LaunchDarkly through a web proxy:
>
> ```csharp title="C#" lines wrap theme={null}
> var handler = new System.Net.Http.HttpClientHandler();
> handler.Proxy = new System.Net.WebProxy("http://my-proxy-host:8080");
>
> var config = Configuration
> .Builder("example-mobile-key", ConfigurationBuilder.AutoEnvAttributes.Enabled)
> .Http(Components.HttpConfiguration().MessageHandler(handler))
> .Build();
> ```
>
> To configure the client-side .NET SDK to connect to LaunchDarkly through a web proxy with authentication:
>
> ```csharp title="C#" lines wrap theme={null}
> var handler = new System.Net.Http.HttpClientHandler();
> var proxy = new System.Net.WebProxy("http://my-proxy-host:8080");
> var credentials = new System.Net.CredentialCache();
> credentials.Add(proxy.Address, "Basic",
> new NetworkCredential("username", "password"));
> proxy.Credentials = credentials;
> handler.Proxy = proxy;
>
> var config = Configuration
> .Builder("example-mobile-key", ConfigurationBuilder.AutoEnvAttributes.Enabled)
> .Http(Components.HttpConfiguration().MessageHandler(handler))
> .Build();
> ```
### C++ (client-side)
> **Expand C++ (client-side) code sample**
>
> > [!NOTE]
> >
> > **Supported versions**
> >
> > This feature is available starting in version 3.11. It requires an SDK build with curl networking enabled (`-DLD_CURL_NETWORKING=ON`).
>
> The SDK supports HTTP, HTTPS, and SOCKS proxies. If you do not configure a proxy explicitly, the SDK uses curl's proxy environment variables (`ALL_PROXY`, `HTTP_PROXY`, `HTTPS_PROXY`). To disable proxy usage, including the environment variables, set the proxy to an empty string.
>
> To configure the client-side C++ SDK to connect to LaunchDarkly through a web proxy:
>
> ```cpp title="C++ SDK v3.11+ (native)" lines wrap theme={null}
> // Requires an SDK build with -DLD_CURL_NETWORKING=ON.
> auto config_builder = client_side::ConfigBuilder("example-mobile-key");
> config_builder.HttpProperties().Proxy("https://web-proxy.domain.com:8080");
> ```
>
> ```c title="C++ SDK v3.11+ (C binding)" lines wrap theme={null}
> /* Requires an SDK build with -DLD_CURL_NETWORKING=ON. */
> LDClientConfigBuilder builder = LDClientConfigBuilder_New("example-mobile-key");
> LDClientConfigBuilder_HttpProperties_Proxy(builder, "https://web-proxy.domain.com:8080");
> ```
>
> To configure the client-side C++ SDK to connect to LaunchDarkly through a web proxy with authentication:
>
> ```cpp title="C++ SDK v3.11+ (native)" lines wrap theme={null}
> // Requires an SDK build with -DLD_CURL_NETWORKING=ON.
> auto config_builder = client_side::ConfigBuilder("example-mobile-key");
> config_builder.HttpProperties().Proxy(
> "https://username:password@web-proxy.domain.com:8080");
> ```
>
> ```c title="C++ SDK v3.11+ (C binding)" lines wrap theme={null}
> /* Requires an SDK build with -DLD_CURL_NETWORKING=ON. */
> LDClientConfigBuilder builder = LDClientConfigBuilder_New("example-mobile-key");
> LDClientConfigBuilder_HttpProperties_Proxy(
> builder, "https://username:password@web-proxy.domain.com:8080");
> ```
## Server-side SDKs
* [.NET (server-side)](#net-server-side)
* [Apex](#apex)
* [Go](#go)
* [Java](#java)
* [Node.js (server-side)](#node-js-server-side)
* [PHP](#php)
* [Python](#python)
* [Ruby](#ruby)
* [Rust](#rust)
### .NET (server-side)
> **Expand .NET (server-side) code sample**
>
> To configure the server-side .NET SDK to connect to LaunchDarkly through a web proxy:
>
> ```csharp title="C#" lines wrap theme={null}
> var proxy = new System.Net.WebProxy("http://my-proxy-host:8080");
>
> var config = Configuration.Builder("YOUR_SDK_KEY")
> .Http(Components.HttpConfiguration().Proxy(proxy))
> .Build();
> ```
>
> To configure the server-side .NET SDK to connect to LaunchDarkly through a web proxy with authentication:
>
> ```csharp title="C#" lines wrap theme={null}
> var proxyUri = new Uri("http://my-proxy-host:8080");
> var proxy = new System.Net.WebProxy(proxyUri);
> var credentials = new System.Net.CredentialCache();
> credentials.Add(proxy.Address, "Basic",
> new NetworkCredential("username", "password"));
> proxy.Credentials = credentials;
>
> var config = Configuration.Builder("YOUR_SDK_KEY")
> .Http(Components.HttpConfiguration().Proxy(proxy))
> .Build();
> ```
>
> This example uses basic authentication. However, other options are supported: the `proxy` that you pass to the `ConfigurationBuilder` in the line `.Http(Components.HttpConfiguration().Proxy(proxy))` can be any implementation of `System.Net.IWebProxy`. If you choose to use a different implementation of `System.Net.IWebProxy`, you may need to make corresponding configuration updates elsewhere in your system. For example, if you use Microsoft's [NTLM authentication](https://learn.microsoft.com/en-us/troubleshoot/windows-server/windows-security/ntlm-user-authentication), you may also need to enable `System.Net.Security.UseManagedNtlm` in your .NET project.
>
> To learn more, read [`Http`](https://launchdarkly.github.io/dotnet-core/pkgs/sdk/server/api/LaunchDarkly.Sdk.Server.ConfigurationBuilder.html#LaunchDarkly_Sdk_Server_ConfigurationBuilder_Http_LaunchDarkly_Sdk_Server_Subsystems_IComponentConfigurer_LaunchDarkly_Sdk_Server_Subsystems_HttpConfiguration__) and [`HttpConfigurationBuilder`](https://launchdarkly.github.io/dotnet-core/pkgs/sdk/server/api/LaunchDarkly.Sdk.Server.Integrations.HttpConfigurationBuilder.html).
### Apex
> **Expand Apex code sample**
>
> The Apex bridge that provides and retrieves flag values is written in Go, and uses the default Go networking mechanisms.
>
> Go's standard HTTP library recognizes the environment variables `HTTP_PROXY` and `HTTPS_PROXY`. If you set these variables, the SDK will connect through a web proxy at the URL you provide. Because the LaunchDarkly services have `https:` URLs, you use `HTTPS_PROXY`. If you are connecting to services at an insecure `http:` URL use `HTTP_PROXY` instead.
>
> Here is an example:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> ```batch title="cmd" lines wrap theme={null}
> set HTTPS_PROXY=https://my-proxy-host:8080
> ```
### Go
> **Expand Go code sample**
>
> There are two ways to specify proxy server parameters in the Go SDK.
>
> Go's standard HTTP library recognizes the environment variables `HTTP_PROXY` and `HTTPS_PROXY`. If you set these variables, the SDK will connect through a web proxy at the URL you provide. Because the LaunchDarkly services have `https:` URLs, you use `HTTPS_PROXY`. If you are connecting to services at an insecure `http:` URL, such as a Relay Proxy instance, use `HTTP_PROXY` instead.
>
> Here is an example:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> ```text title="cmd" lines wrap theme={null}
> set HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> You can also specify a proxy programmatically through the SDK configuration:
>
> ```go title="Go SDK v6+" lines wrap theme={null}
> import (
> ld "github.com/launchdarkly/go-server-sdk/v6"
> "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
> )
>
> var config ld.Config
> config.HTTP = ldcomponents.HTTPConfiguration().
> ProxyURL("https://my-proxy-host:8080")
> ```
### Java
> **Expand Java code sample**
>
> To configure the Java SDK to connect to LaunchDarkly through a web proxy:
>
> ```java title="Java" lines wrap theme={null}
> LDConfig config = new LDConfig.Builder()
> .http(Components.httpConfiguration().proxyHostAndPort("my-proxy-host", 8080))
> .build();
> ```
>
> To configure the Java SDK to connect to LaunchDarkly through a web proxy with authentication:
>
> ```java title="Java" lines wrap theme={null}
> LDConfig config = new LDConfig.Builder()
> .http(Components.httpConfiguration()
> .proxyHostAndPort("my-proxy-host", 8080)
> .proxyAuth(Components.httpBasicAuthentication("username", "password")))
> .build();
> ```
### Node.js (server-side)
> **Expand Node.js (server-side) code sample**
>
> To configure the server-side Node.js SDK to connect to LaunchDarkly through a web proxy:
>
> ```ts title="Node.js SDK v8.x+ (TypeScript)" lines wrap theme={null}
> import { LDOptions } from '@launchdarkly/node-server-sdk';
>
> const options: LDOptions = {
> proxyOptions: {
> host: 'your-proxy-host',
> port: 8080,
> scheme: 'https'
> }
> };
> ```
>
> ```js title="Node.js SDK v8.x+ (JavaScript)" lines wrap theme={null}
> const options = {
> proxyOptions: {
> host: 'your-proxy-host',
> port: 8080,
> scheme: 'https'
> }
> };
> ```
>
> To configure the server-side Node.js SDK to connect to LaunchDarkly through a web proxy with authentication:
>
> ```ts title="Node.js SDK v8.x+ (TypeScript)" lines wrap theme={null}
> import { LDOptions } from '@launchdarkly/node-server-sdk';
>
> const options: LDOptions = {
> proxyOptions: {
> host: 'your-proxy-host',
> port: 8080,
> scheme: 'https',
> auth: 'username:password'
> }
> };
> ```
>
> ```js title="Node.js SDK v8.x+ (JavaScript)" lines wrap theme={null}
>
> const options = {
> proxyOptions: {
> host: 'your-proxy-host',
> port: 8080,
> scheme: 'https',
> auth: 'username:password'
> }
> };
> ```
>
> To learn more, read [`proxyOptions`](https://launchdarkly.github.io/js-core/packages/sdk/server-node/docs/interfaces/LDOptions.html#proxyOptions).
### PHP
> **Expand PHP code sample**
>
> There are two ways to specify proxy server parameters in the PHP SDK.
>
> If you do not configure a proxy in the SDK, its HTTP clients use the proxy environment variables. If you set `HTTPS_PROXY`, the SDK connects through a web proxy at the URL you provide. Because the LaunchDarkly services have `https:` URLs, you use `HTTPS_PROXY`. If you are connecting to services at an insecure `http:` URL, such as a Relay Proxy instance, use the `http_proxy` option. The SDK reads `HTTP_PROXY` only when PHP runs from the command line.
>
> > [!NOTE]
> >
> > **Supported versions**
> >
> > The `http_proxy` option is available in the PHP SDK's version 6.10.0 and later.
>
> You can also specify a proxy in the SDK configuration. The SDK uses this proxy for its own connections in place of the proxy environment variables:
>
> ```php title="PHP" lines wrap theme={null}
> $client = new LaunchDarkly\LDClient("YOUR_SDK_KEY", [
> "http_proxy" => "http://my-proxy-host:8080"
> ]);
> ```
>
> To configure the PHP SDK to connect to LaunchDarkly through a web proxy with authentication, include the credentials in the proxy URL. On Windows, the default event publisher does not read credentials from the proxy URL. The Windows example uses the Guzzle event publisher instead:
>
> ```php title="PHP" lines wrap theme={null}
> $client = new LaunchDarkly\LDClient("YOUR_SDK_KEY", [
> "http_proxy" => "http://username:password@my-proxy-host:8080"
> ]);
> ```
>
> ```php title="PHP (Windows)" lines wrap theme={null}
> $client = new LaunchDarkly\LDClient("YOUR_SDK_KEY", [
> "http_proxy" => "http://username:password@my-proxy-host:8080",
> "event_publisher" => LaunchDarkly\Integrations\Guzzle::eventPublisher()
> ]);
> ```
### Python
> **Expand Python code sample**
>
> There are two ways to specify proxy server parameters in the Python SDK.
>
> Python's standard HTTP library recognizes the environment variables `HTTP_PROXY` and `HTTPS_PROXY`. If you set these variables, the SDK will connect through a web proxy at the URL you provide. Because the LaunchDarkly services have `https:` URLs, you use `HTTPS_PROXY`. If you are connecting to services at an insecure `http:` URL, such as a Relay Proxy instance, use `HTTP_PROXY` instead.
>
> How to set the HTTPS\_PROXY environment variable on Mac/Linux and Windows systems:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> ```bash title="cmd" lines wrap theme={null}
> set HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> Or it can be set from within Python:
>
> ```python title="Python" lines wrap theme={null}
> import os
>
> os.environ["HTTPS_PROXY"] = "https://my-proxy-host:8080"
> ```
### Ruby
> **Expand Ruby code sample**
>
> There are two ways to specify proxy server parameters in the Ruby SDK.
>
> Ruby's standard HTTP library recognizes the environment variables `HTTP_PROXY` and `HTTPS_PROXY`. If you set these variables, the SDK will connect through a web proxy at the URL you provide. Because the LaunchDarkly services have `https:` URLs, you use `HTTPS_PROXY`. If you are connecting to services at an insecure `http:` URL, such as a Relay Proxy instance, use `HTTP_PROXY` instead.
>
> To configure the Ruby SDK to connect to LaunchDarkly through a web proxy:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> ```batch title="cmd" lines wrap theme={null}
> set HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> Or it can be set from within Ruby:
>
> ```ruby title="Ruby" lines wrap theme={null}
> ENV['HTTPS_PROXY'] = 'https://my-proxy-host:8080'
> ```
### Rust
> **Expand Rust code sample**
>
> > [!NOTE]
> >
> > **Supported versions**
> >
> > This feature is available in the Rust SDK's version 3.0 and later.
>
> Starting in version 3.0, the Rust SDK's transport layer automatically detects proxy settings from environment variables. The SDK supports `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY`. Lowercase variants take precedence over uppercase.
>
> The proxy routing behavior is:
>
> * **Both `HTTP_PROXY` and `HTTPS_PROXY` set**: HTTP requests use `HTTP_PROXY`, HTTPS requests use `HTTPS_PROXY`.
> * **Only `HTTP_PROXY` set**: All requests, including HTTPS, route through `HTTP_PROXY`.
> * **Only `HTTPS_PROXY` set**: Only HTTPS requests use the proxy. HTTP requests connect directly.
> * **Neither set**: All requests connect directly with no proxy.
>
> Use `NO_PROXY` to bypass the proxy for specific hosts. It accepts a comma-separated list of host names or `*` to disable the proxy for all hosts.
>
> Here is an example:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY=https://my-proxy-host:8080
> ```
>
> To configure the Rust SDK to connect to LaunchDarkly through a web proxy with authentication, include the credentials in the proxy URL:
>
> ```bash title="Console" lines wrap theme={null}
> export HTTPS_PROXY="https://username:password@my-proxy-host:8080"
> ```
>
> You can also configure a proxy programmatically, or disable proxy support entirely:
>
> ```rust title="Rust" lines wrap theme={null}
> use launchdarkly_sdk_transport::HyperTransport;
>
> // Use a custom proxy URL
> let transport = HyperTransport::builder()
> .proxy_url("https://my-proxy-host:8080".to_string())
> .build_http()?;
>
> // Disable proxy completely
> let transport = HyperTransport::builder()
> .disable_proxy()
> .build_http()?;
> ```