Proxy Configuration in PyCharm, IntelliJ IDEA, and WebStorm: A Complete Guide for Developers

```html

If plugins in JetBrains IDE are not installing, Maven or pip cannot download dependencies, and the Marketplace simply won't open — the issue is likely due to network restrictions. A proxy solves this in a matter of minutes. In this article, we will cover all methods of configuration: through the built-in IDE interface, through system variables, and through configuration files — for PyCharm, IntelliJ IDEA, WebStorm, GoLand, and other JetBrains products.

Why a developer needs a proxy in the IDE

JetBrains IDEs actively access the network: downloading plugins from the Marketplace, updating indexes, pulling dependencies from Maven Central, PyPI, npm, and other repositories, checking licenses, and synchronizing settings through JetBrains Account. If even one of these requests is blocked — work slows down or completely halts.

Here are specific situations where a proxy is essential:

• Corporate network with a firewall. Many companies allow external traffic only through a corporate proxy server. Without its configuration in the IDE, plugins will not install, and dependencies will not download.
• Geo-blocking. Some repositories and CDNs are geographically restricted. A proxy with the required location removes this restriction.
• Working from a country with limited internet access. JetBrains Marketplace, GitHub Packages, Maven Central may be unavailable directly.
• Development and testing of network applications. Traffic needs to be routed through a specific node to check the application's behavior from another region.
• Security in public networks. When working from a café or coworking space, a proxy encrypts the IDE's traffic and protects tokens and keys from interception.
• Bypassing sanctions restrictions. After 2022, several external repositories and services imposed IP restrictions — a proxy allows continued work without changing tools.

Unlike a browser, where a proxy is configured once and works globally, in JetBrains IDEs, the proxy needs to be set up separately — and sometimes in several places at once: in the IDE itself, in the dependency manager, and in the language interpreter. Let's break down each level in order.

Which type of proxy to choose for JetBrains

JetBrains IDEs support three types of proxies: HTTP, HTTPS, and SOCKS5. For most developer tasks, HTTP/HTTPS proxies will suffice — they work transparently with all requests from the IDE, Maven, Gradle, and pip. SOCKS5 provides more flexibility and operates at the TCP level, which is useful for non-standard protocols.

Proxy Type	IDE Support	Suitable for	Features
HTTP/HTTPS	✅ Native	Plugins, dependencies, license	Easiest to configure
SOCKS5	✅ Native	Any TCP connections	Supports authentication
PAC file	✅ Through system settings	Corporate networks	Flexible routing
System proxy	✅ Auto-detection	When already configured in the OS	Does not require additional configuration

If you are working with a corporate proxy — it is likely HTTP/HTTPS with authentication by username and password. If you are connecting to an external proxy service to bypass blocks, consider datacenter proxies — they provide high speed and connection stability, which is critical when downloading large dependencies and indexes.

Configuring the proxy through the IDE interface (HTTP/HTTPS)

This is the simplest and recommended method. The settings apply to all network requests from the IDE: Marketplace, updates, license checks, plugin synchronization. The instructions are the same for PyCharm, IntelliJ IDEA, WebStorm, GoLand, Rider, CLion, and other products in the lineup.

Step 1. Open IDE settings

On Windows and Linux: File → Settings (or Ctrl+Alt+S).
On macOS: PyCharm → Preferences (or Cmd+,).

Step 2. Find the proxy section

In the left panel of settings, navigate to: Appearance & Behavior → System Settings → HTTP Proxy. Or simply start typing the word proxy in the settings search bar — the IDE will immediately show the required section.

Step 3. Select the proxy type and fill in the details

In the HTTP Proxy section, you will see three options:

• No proxy — direct connection (default).
• Auto-detect proxy settings — the IDE will take settings from the operating system.
• Manual proxy configuration — manual setup. Select this option.

When selecting Manual proxy configuration, fill in the fields:

• Host name — IP address or domain of the proxy server. For example: proxy.example.com or 192.168.1.100.
• Port number — proxy port. Standard values: 8080, 3128, 8888.
• No proxy for — hosts that should connect directly (without a proxy). Usually, localhost, 127.0.0.1, and internal company domains are added here.
• Proxy authentication — if the proxy requires a username and password, check the box and enter the credentials.

Step 4. Check the connection

Click the Check connection button and enter any URL — for example, https://plugins.jetbrains.com. If everything is set up correctly, the IDE will show the status Connection successful. After that, click OK and restart the IDE.

Configuring SOCKS5 proxy in JetBrains IDE

SOCKS5 is a more flexible protocol that works not only with HTTP/HTTPS but also with any TCP connections. This is useful if your proxy provider specifically offers SOCKS5 or if you are using an SSH tunnel.

In the JetBrains IDE interface, the SOCKS section is located in the same place: Appearance & Behavior → System Settings → HTTP Proxy. In the Manual proxy configuration block, switch the radio button from HTTP to SOCKS.

Fill in the fields similarly to HTTP proxy:

• Host name — address of the SOCKS5 server.
• Port number — port (usually 1080 or 1081).
• Proxy authentication — username and password, if required.

An important nuance: the built-in SOCKS client in JetBrains IDEs operates at the JVM level and intercepts only those connections that the IDE establishes directly through Java. External processes — Maven Wrapper, Gradle Daemon, pip, npm — run as separate processes and do not inherit proxy settings from the IDE interface. They require separate configuration (see sections below).

Configuration through JVM parameters (vmoptions)

If the settings through the interface do not work (for example, in some versions of the IDE or when using non-standard plugins), you can set the proxy directly through JVM parameters. This is a reliable low-level method that is guaranteed to apply to all JVM connections.

How to open the vmoptions file

In the IDE menu, go to: Help → Edit Custom VM Options.... The file pycharm64.vmoptions (or idea64.vmoptions for IntelliJ IDEA) will open in the user settings directory.

Add the following lines to the end of the file for HTTP proxy:

-Dhttp.proxyHost=your.proxy.host
-Dhttp.proxyPort=8080
-Dhttps.proxyHost=your.proxy.host
-Dhttps.proxyPort=8080
-Dhttp.proxyUser=username
-Dhttp.proxyPassword=password
-Dhttps.proxyUser=username
-Dhttps.proxyPassword=password
-Dhttp.nonProxyHosts=localhost|127.0.0.1|*.local

For SOCKS5 proxy, use the following parameters:

-DsocksProxyHost=your.socks.host
-DsocksProxyPort=1080
-DsocksProxyVersion=5

After saving the file, restart the IDE. The parameters will apply to all JVM connections, including index loading, plugin operations, and the built-in Git client.

Proxy through system environment variables

This method is especially convenient on Linux and macOS, as well as in CI/CD environments. Environment variables are inherited not only by the JVM but also by child processes — meaning Maven, Gradle, pip, npm will also automatically pick them up.

Standard variables for HTTP proxy:

export HTTP_PROXY=http://username:[email protected]:8080
export HTTPS_PROXY=http://username:[email protected]:8080
export NO_PROXY=localhost,127.0.0.1,::1

Add these lines to ~/.bashrc, ~/.zshrc, or ~/.profile depending on your shell. After that, restart the terminal and launch the IDE from it — it will pick up the environment variables.

On Windows, variables are set through the system interface:

1. Open Control Panel → System → Advanced system settings → Environment Variables.
2. In the "User variables" block, click Create.
3. Add the variables HTTP_PROXY and HTTPS_PROXY with the value http://username:[email protected]:8080.
4. Restart the IDE.

Note: JetBrains IDE on Windows runs as a separate process through a launcher, and environment variables set in the current terminal session may not be passed to the IDE. It is more reliable to set them through the system interface or through the vmoptions file.

Proxy for Maven and Gradle inside IntelliJ IDEA

Maven and Gradle are separate tools with their own configuration files. Even if the proxy is configured in the IDE interface, the Maven Wrapper and Gradle Daemon may ignore these settings because they run as standalone JVM processes.

Proxy for Maven

Open the file ~/.m2/settings.xml (create it if it does not exist) and add the section <proxies>:

<settings>
  <proxies>
    <proxy>
      <id>main-proxy</id>
      <active>true</active>
      <protocol>https</protocol>
      <host>proxy.example.com</host>
      <port>8080</port>
      <username>your_username</username>
      <password>your_password</password>
      <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>
    </proxy>
  </proxies>
</settings>

If you need to configure the proxy separately for HTTP and HTTPS, add two <proxy> blocks with different id and protocol.

Proxy for Gradle

For Gradle, proxy settings are specified in the ~/.gradle/gradle.properties file (globally) or in the gradle.properties file in the project root (for a specific project):

systemProp.http.proxyHost=proxy.example.com
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=your_username
systemProp.http.proxyPassword=your_password
systemProp.http.nonProxyHosts=localhost|127.0.0.1

systemProp.https.proxyHost=proxy.example.com
systemProp.https.proxyPort=8080
systemProp.https.proxyUser=your_username
systemProp.https.proxyPassword=your_password

After saving the file, IntelliJ IDEA will automatically pick up the new settings during the next Gradle project synchronization. Click the Reload All Gradle Projects button (the refresh icon in the Gradle panel on the right) — and dependencies will start downloading through the proxy.

Proxy for pip and conda in PyCharm

PyCharm is the primary IDE for Python developers. Installing packages via pip and conda occurs through separate processes that do not read proxy settings from the PyCharm interface. Here’s how to configure the proxy for each package manager.

Proxy for pip

Method 1 — through the command line argument when installing a package:

pip install requests --proxy http://username:[email protected]:8080

Method 2 — through the pip configuration file (applies permanently). Open or create the file:

• Linux/macOS: ~/.config/pip/pip.conf
• Windows: %APPDATA%\pip\pip.ini

[global]
proxy = http://username:[email protected]:8080

Method 3 — through environment variables (works for both pip and other Python tools):

export HTTP_PROXY=http://username:[email protected]:8080
export HTTPS_PROXY=http://username:[email protected]:8080

Proxy for conda

Conda uses its own configuration file .condarc. Open it in your home directory and add:

proxy_servers:
  http: http://username:[email protected]:8080
  https: http://username:[email protected]:8080

Or run the command in the PyCharm terminal:

conda config --set proxy_servers.http http://proxy.host:8080
conda config --set proxy_servers.https http://proxy.host:8080

If you are working with PyPI mirrors (for example, Yandex mirror or corporate Nexus), you can switch pip to an alternative index instead of using a proxy. But if the mirror is also unavailable — the proxy remains the only solution. For stable work with PyPI, residential proxies are well-suited — they appear as regular user requests and are not blocked by PyPI CDN providers.

Common issues and solutions

Even with correct settings, sometimes things go wrong. Let's discuss the most common issues and how to resolve them.

Issue 1: "Connection refused" or "Unable to connect to proxy"

Reason: incorrect host, port, or the proxy is unavailable.
Solution: check the address and port of the proxy. Try connecting to the proxy via curl in the terminal:

curl -x http://proxy.host:8080 https://plugins.jetbrains.com

If curl also cannot connect — the issue lies with the proxy itself, not the IDE settings.

Issue 2: Proxy is configured, but plugins still do not install

Reason: the IDE cached old settings or the settings did not apply to all components.
Solution:

1. Fully close the IDE (make sure the process is not hanging in the background).
2. Clear the cache: File → Invalidate Caches → Invalidate and Restart.
3. Check that there are no conflicting parameters in the vmoptions file.

Issue 3: SSL/TLS error when working through a proxy

Reason: the corporate proxy performs SSL inspection (MITM) and replaces certificates. The JVM does not trust the replaced certificate.
Solution: ask your system administrator to provide the root certificate of the corporate CA and import it into the Java KeyStore:

keytool -import -alias corporate-ca -keystore $JAVA_HOME/lib/security/cacerts \
  -file corporate-ca.crt -storepass changeit

JetBrains IDE has a built-in tool: Settings → Tools → Server Certificates — where you can add a trusted certificate through the GUI.

Issue 4: Proxy with authentication does not accept the password

Reason: special characters in the password are not escaped, or the proxy uses NTLM/Kerberos authentication (Microsoft corporate proxies).
Solution: for NTLM proxies, the JVM supports it natively, but you need to set additional parameters:

-Djdk.http.auth.tunneling.disabledSchemes=""
-Djdk.http.auth.proxying.disabledSchemes=""

Issue 5: Git inside the IDE does not work through the proxy

Reason: the built-in Git client in JetBrains uses the system Git, not JVM connections. Proxy settings from the IDE do not affect it.
Solution: configure the proxy directly in Git:

git config --global http.proxy http://username:[email protected]:8080
git config --global https.proxy http://username:[email protected]:8080

Symptom	Likely cause	How to fix
Plugins are not installing	Proxy is not configured in the IDE	Settings → HTTP Proxy
Maven is not downloading dependencies	No settings in settings.xml	~/.m2/settings.xml → proxies
pip is not installing packages	pip does not read IDE settings	pip.conf or ENV variables
SSL errors	MITM inspection on the proxy	Import corporate certificate
Git does not work through the proxy	Git does not read JVM settings	git config --global http.proxy
Gradle is not synchronizing	No settings in gradle.properties	~/.gradle/gradle.properties

Conclusion

Configuring a proxy in JetBrains IDE is not a one-button task, but several levels of configuration. The main thing to remember is that the IDE itself (plugins, license, Marketplace) is configured through Settings → HTTP Proxy or through JVM parameters in vmoptions. Dependency managers — Maven, Gradle, pip, conda — require separate configuration in their configuration files. Git inside the IDE is configured through the global git config.

If you are using a proxy to bypass geo-blocks or corporate network restrictions, it is important to choose a stable and fast proxy server. For working with repositories, the Marketplace, and downloading dependencies, datacenter proxies are well-suited — they provide high speed and minimal latency, which is critical when synchronizing large projects with hundreds of dependencies. If maximum compatibility with services that block server IPs is needed, consider residential proxies — they use real user addresses and are practically undetectable by CDN and repository security systems.