GitHub Copilot Not Working in IntelliJ: Safe Fixes for Plugin, Sign-In, Proxy, and Logs

Overview

When GitHub Copilot stops working in IntelliJ IDEA, the editor is usually failing at one of four points: the JetBrains plugin is not loaded, GitHub authorization did not complete cleanly, network traffic is being blocked or inspected, or the current file is poor context for suggestions. Treat those as separate layers. A browser that can open GitHub.com does not prove the IntelliJ plugin can authenticate or reach the same services.

Start with reversible checks. Confirm the GitHub Copilot plugin is installed and enabled, restart IntelliJ IDEA, use the IDE menu action for Copilot sign-in, then test in a small normal source file. GitHub documents JetBrains setup for Copilot in its official Copilot IDE setup documentation, and JetBrains documents plugin management in IntelliJ IDEA plugin management.

Do not reset IntelliJ settings just because completions disappear. First isolate the surface: plugin visible or missing, account signed in or looping, one project or every project, home network or managed proxy. If you need to involve support, IntelliJ can open its log directory from Help → Show Log in Explorer/Finder/File Manager; safe search terms include copilot, github, plugin, proxy, certificate, and auth.

Symptoms

In IntelliJ IDEA, Copilot issues usually appear as missing inline suggestions, a disabled or absent Copilot menu, repeated GitHub authorization prompts, Chat not responding, or completions disappearing after an IDE or plugin update. The plugin may also show as installed while its actions do nothing.

Keep the diagnosis local until you have current evidence from an official status or support source. Check whether the problem follows the account, the IDE, the network, or one repository. A blocked proxy connection and a stale sign-in token can look almost identical from the editor, so avoid jumping straight to a full reinstall.

Why This Happens

GitHub Copilot in IntelliJ depends on a JetBrains plugin, a valid GitHub authorization flow, outbound network access, and useful editor context. If one layer fails, suggestions may simply stop appearing instead of showing a clear project-level error.

Corporate VPNs, HTTP proxies, firewalls, and TLS inspection can affect IDE traffic differently from browser traffic. JetBrains documents the IDE proxy surface in IntelliJ IDEA HTTP Proxy settings. Browser authorization can also complete under the wrong GitHub account when work and personal sessions share one browser profile.

Use the least destructive path first: restart, verify plugin state, refresh authorization, test a clean source file, then inspect network settings and logs. Reinstall the Copilot plugin only after those checks. Save a full IDE reset for cases where logs or support guidance point to corrupted IDE state.

Check status, account, and basic access

Open IntelliJ IDEA and look for the Copilot actions under Tools → GitHub Copilot. If the IDE asks you to authenticate, choose Login to GitHub and complete the browser flow with the account that should have Copilot access. On shared machines or mixed work/personal browsers, sign out of other GitHub sessions first or use a private browser window for the authorization step.

A successful GitHub website login is not the same as Copilot access in the IDE. If your organization manages Copilot, confirm the GitHub account and organization context with an admin. If Copilot fails across every editor and network you try, then it is reasonable to check official GitHub support or status channels, but do not assume an outage without current evidence.

Try a clean IntelliJ session

Restart IntelliJ IDEA after enabling or updating the plugin. Plugin changes often require a restart, and a half-loaded plugin can look like a service-side Copilot failure.

Then open one ordinary source file inside an imported project. Avoid scratch files, generated folders, build output, lock files, vendored dependencies, and minified files for the first test. Add a short comment such as // create a function that validates an email address and pause in the editor. If suggestions appear there but not in your original file, focus on file type, project indexing, generated-code marking, or repository-specific context rather than account access.

Check plugin installation and IDE compatibility

Open Settings → Plugins → Installed and search for GitHub Copilot. If the plugin is disabled, enable it and restart. If it is installed but inconsistent, update it through the JetBrains Marketplace when an update is offered, then restart again.

If updating does not help, uninstall GitHub Copilot from the plugin UI, restart IntelliJ, install it again from the Marketplace, and restart once more. This targets Copilot plugin state without removing keymaps, inspections, SDKs, run configurations, or workspace preferences. Avoid manually copying plugin files into IDE directories because stale metadata can survive across IDE builds.

IntelliJ IDEA plugin path:
Settings → Plugins → Installed → GitHub Copilot

Safe order:
Enable if disabled
Update if an update is offered
Restart IntelliJ IDEA
Reinstall the Copilot plugin only if it remains broken

Refresh Copilot authentication

Authentication failures often look like silent completion failures. In IntelliJ IDEA, use Tools → GitHub Copilot → Logout from GitHub, restart the IDE, then use Tools → GitHub Copilot → Login to GitHub. If your installed plugin version uses slightly different wording, choose the Copilot menu actions that explicitly log out of GitHub and start GitHub login.

When the browser opens, check the GitHub username before approving access. This matters on machines where work and personal GitHub accounts share the same browser profile. If the authorization page opens but IntelliJ never receives the result, retry with a private browser window or temporarily change the default browser. Browser extensions, blocked redirects, and strict privacy settings can interrupt the handoff from GitHub back to the IDE.

Check proxy, VPN, firewall, and certificates

Developer environments often route IDE traffic differently from browser traffic. Copilot may fail in IntelliJ while GitHub.com works in the browser because IntelliJ uses its own proxy configuration, certificate trust, or JVM network settings.

Open Settings → Appearance & Behavior → System Settings → HTTP Proxy and confirm the configuration matches your environment. On a managed network, ask whether GitHub Copilot traffic is allowed and whether TLS inspection applies to IDE processes. Do not bypass corporate controls without permission. On a personal machine, a short test with VPN or security filtering paused can help isolate the cause, but treat that as a diagnostic step rather than a permanent fix.

Check file, permission, and project context

Copilot suggestions depend on editor context. A project that is still indexing, a file marked as plain text, a generated directory, or a file outside the project root can reduce or suppress suggestions. Check that IntelliJ recognizes the language correctly and that the file is editable.

Use a concrete isolation step: create or open a small source file under the normal source root, add a simple comment prompt, and wait briefly for an inline suggestion. If Copilot works there but not in the original file, compare file type, ignored paths, generated-source settings, file size, and whether the project was imported correctly. Opening a single file without importing the project can remove context that both IntelliJ and Copilot rely on.

Run platform-specific IntelliJ checks

On macOS, Windows, and Linux, confirm the IDE can open the browser for authentication and that firewall rules allow the JetBrains process. If the browser never opens, the failure may be local desktop integration rather than Copilot entitlement.

For remote development, separate the local JetBrains client, the remote IDE backend, and the repository host. A proxy configured on your laptop may not apply to the remote backend. In WSL or container-based workflows, verify where IntelliJ is actually running and where the plugin executes. Fix the environment that owns the IDE process, not only the terminal where project commands run.

Inspect IntelliJ logs before resetting settings

If Copilot remains unavailable, collect logs before destructive changes. In IntelliJ IDEA, choose Help → Show Log in Explorer on Windows, Help → Show Log in Finder on macOS, or Help → Show Log in File Manager on Linux. Search recent log files for copilot, github, plugin, proxy, certificate, auth, and oauth.

Those terms do not guarantee a root cause, but they produce a better support report than another reinstall attempt. Record the approximate time of the failure, IDE name and build if visible in About, operating system, plugin state, network type, whether browser sign-in completed, and whether the issue affects one project or all projects. Remove tokens, private repository names, customer names, and full internal paths before posting logs publicly.

Useful report fields:
- IDE: IntelliJ IDEA edition and build, if visible in About
- OS: macOS, Windows, or Linux
- Plugin: GitHub Copilot installed, enabled, and update state
- Account: Login to GitHub succeeds, loops, or fails
- Network: home, VPN, proxy, corporate firewall, remote development
- Scope: all projects or one repository
- Logs: short redacted lines around copilot, github, proxy, certificate, auth, or oauth messages

Reinstall the Copilot plugin safely

Reinstall the plugin only after restart, account refresh, project-context testing, and network checks. Remove GitHub Copilot from Settings → Plugins, restart IntelliJ, install it again from the JetBrains Marketplace, and restart once more.

This sequence preserves IDE-level settings while replacing Copilot plugin state. If reinstalling helps only until the next IDE start, inspect startup errors and possible plugin conflicts. Security tools, proxy helpers, and other AI/editor-assistance plugins can affect the same editor surfaces. Use a minimal plugin set only as a temporary diagnostic step, not as the final workaround.

When to use another editor as a control test

Testing Copilot in VS Code or another JetBrains IDE can be useful as a control. If Copilot works elsewhere with the same GitHub account and network, the IntelliJ plugin, IDE settings, project model, or local environment is the likely fault.

If Copilot fails everywhere, focus on account access, organization policy, network controls, or official service information. Do not switch editors as the main fix unless your team already supports that workflow. For Java, Kotlin, Gradle, Maven, and Spring projects, IntelliJ’s project model may be central to the way the project builds and runs.

If It Still Fails

Escalate with evidence instead of repeating reinstall cycles. Capture IntelliJ logs, screenshots of plugin state, the sign-in result, network context, and whether the failure affects one project or all projects. Check official GitHub help or status channels if you suspect a service-side problem, but do not assume an outage without current confirmation.

If your organization manages Copilot, include the GitHub account and organization name when contacting an admin. For internal BUGIcodes troubleshooting paths, use [INTERNAL:github copilot not working], [INTERNAL:copilot chat not working], and [INTERNAL:intellij ai assistant not working].