# How to Install Claude Code in 2026: Complete Guide for Mac, Windows & Linux

> Claude Code installs in under two minutes on macOS, Linux, and Windows using the native CLI installer with zero dependencies. This guide covers all six installation methods including native, Homebrew, WinGet, npm, Windows CMD, and WSL. Learn which Claude plan fits your workflow, how to authenticate, set up CLAUDE.md, troubleshoot common errors, and start coding with AI in your terminal.

- URL: https://blog.laozhang.ai/en/posts/how-to-install-claude-code
- Published: 2026-03-16
- Updated: 2026-10-21
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Claude Code
- Tags: Claude Code, Installation Guide, AI Coding Tools, Developer Tools

---
Claude Code is Anthropic's terminal-based AI coding agent that reads your codebase, edits files, runs commands, and manages git — all from the command line. As of October 2026, the recommended installation method is the native CLI installer, which requires zero dependencies, auto-updates in the background, and works on macOS, Linux, and Windows. Whether you are setting up Claude Code for the first time or migrating from an older npm-based installation, this guide walks you through every option available in 2026 so you can start coding with AI assistance in minutes rather than hours.

## TL;DR

Claude Code installs with a single command on every major platform. Here is what you need to know before reading the full guide:

- **macOS / Linux**: `curl -fsSL https://claude.ai/install.sh | bash`
- **Windows PowerShell**: `irm https://claude.ai/install.ps1 | iex`
- **Requirements**: macOS 13+, Windows 10 1809+, or Ubuntu 20.04+. A Claude Pro subscription ($20/month) or higher is mandatory — the free tier does not include Claude Code access.
- **Six methods exist**: Native installer (recommended), Homebrew, WinGet, npm, Windows CMD, and WSL. Native installs (including the CMD installer and the Linux installer inside WSL) update themselves, and so do npm global installs as long as the npm global folder is writable. Homebrew and WinGet need a manual upgrade by default.
- **First launch**: Run `claude` in your terminal, authenticate through your browser, and you are ready to go.

If you just want the commands and nothing else, copy the one above for your platform and skip to the [Authentication and First Launch](#authentication-and-first-launch) section. For everyone who wants to understand the differences between methods, handle Windows edge cases, or pick the right Claude plan, keep reading.

## What You Need Before Installing Claude Code


Before running any installation command, you need to verify two things: your operating system meets the minimum requirements, and you have the right kind of Anthropic account. Skipping this step is the number one reason developers waste time on failed installations.

### System Requirements

Claude Code supports three major platforms, but the version requirements are stricter than most CLI tools. Running on an older operating system version will cause silent failures during installation or authentication, so check your version first.

On macOS, you need version 13.0 (Ventura) or later. Apple Silicon and Intel machines are both supported through the native installer. If you are unsure of your version, click the Apple menu and select "About This Mac." Most developers running Xcode-compatible setups already meet this requirement, but it catches people who are still on older MacBook hardware running macOS Monterey or earlier. The terminal app that ships with macOS works perfectly — you do not need iTerm2 or any third-party terminal, though they work fine too.

On Windows, you need version 10 build 1809 or later, which covers Windows 10 October 2018 Update and everything since, including Windows 11. Git for Windows is optional, not a prerequisite. Without it, Claude Code runs shell commands through its PowerShell tool. With it, Claude Code also gets Git Bash for its Bash tool, which helps when your project relies on Bash scripts. If you want that, download Git for Windows from [git-scm.com](https://git-scm.com/downloads/win), select "Add to PATH" during setup, and restart your terminal. You do not need to run the Claude Code installer as Administrator. Windows Server 2019 and later is also supported for CI/CD use cases.

On Linux, the officially supported operating systems are Ubuntu 20.04 and later, Debian 10 and later, and Alpine Linux 3.19 and later. Other distributions, such as Fedora or Arch, are not on the official list, so Anthropic publishes no minimum version for them. Alpine and other musl-based distributions also need `bash`, `curl`, `libgcc`, `libstdc++`, and `ripgrep` installed, plus `USE_BUILTIN_RIPGREP` set to `0` in your settings. The installer detects your architecture automatically (x86_64 or ARM64), so there is nothing extra to configure. If you are running Linux inside WSL on a Windows machine, the Linux installation method works identically — more on that in the Windows section below.

Across all platforms, the official minimum is 4 GB of RAM on an x64 or ARM64 processor; 8 GB gives you more headroom when Claude Code runs alongside your editor and build tools. You also need a stable internet connection for the initial download and authentication. The installed binary is relatively small (under 100 MB), so disk space is rarely a concern.

### Choosing the Right Account

This is where many developers hit an unexpected wall. Claude Code is not available on the free Claude.ai plan. You must have one of the following account types to authenticate and use Claude Code:

| Account Type | Monthly Cost | Best For | Claude Code Access |
|-------------|-------------|----------|-------------------|
| Claude Pro | $20/mo ($17 annual) | Individual developers | Yes — Sonnet 4.6 |
| Claude Max 5x | $100/mo | Daily heavy users | Yes — Opus 4.6 + 5x limits |
| Claude Max 20x | $200/mo | Power users, teams | Yes — Opus 4.6 + 20x limits |
| Teams Standard | $25/seat/mo | Small teams | Yes — Pro-level per seat |
| Anthropic Console | Pay-as-you-go | API-first / CI/CD | Yes — via API key |

If you are trying Claude Code for the first time, the Pro plan at $20 per month is the most sensible starting point. It gives you access to Claude Code in the terminal plus the web interface, and you can upgrade to Max later if you find yourself hitting rate limits during intensive coding sessions. For teams evaluating Claude Code across multiple developers, the Teams plan provides centralized billing and admin controls. The Anthropic Console option is ideal if you only plan to use Claude Code in CI/CD pipelines or prefer pay-per-token pricing rather than a monthly subscription — when you first log in with a Console account, a "Claude Code" workspace is automatically created for cost tracking.

## Install Claude Code on macOS and Linux

Installation on macOS and Linux is straightforward because both platforms share the same installer script. The native installer downloads a compiled binary for your specific platform and architecture. There are no dependencies to manage, no version conflicts with Node.js or nvm, and updates happen automatically in the background. Older npm builds, up to version 2.1.112, ran as JavaScript on your Node.js runtime; since 2.1.113, the npm package installs this same native binary.

### Native Installer (Recommended)

Open your terminal and run a single command:

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

This script downloads the Claude Code binary, places the `claude` launcher at `~/.local/bin/claude` (installed versions live in `~/.local/share/claude/`), and updates your shell PATH so the `claude` command is available globally. The entire process takes about 30 seconds on a decent internet connection. After installation, open a new terminal window (or run `source ~/.zshrc` on macOS, `source ~/.bashrc` on Linux) so your shell picks up the new PATH entry.

The native installer's biggest advantage is automatic updates. Claude Code checks for new versions on startup and periodically while it runs, downloads them in the background, and switches to the new version the next time you start it. You never need to re-run the installer or remember to check for updates — it just stays current. This is particularly important because Anthropic ships improvements to Claude Code weekly, and older versions sometimes lose compatibility with the API.

If the idea of piping a script directly into bash makes you uncomfortable from a security perspective, you can download the script first, inspect it, and then run it manually. This is a perfectly valid approach:

```bash
curl -fsSL https://claude.ai/install.sh -o install-claude.sh
less install-claude.sh  # review the script
bash install-claude.sh
```

### Homebrew Alternative

For developers who prefer managing their tools through Homebrew, Claude Code is available as a cask:

```bash
brew install --cask claude-code
```

This method works on both macOS and Linux (via Linuxbrew). The `claude-code` cask follows the stable release channel, which typically runs about a week behind and skips releases with major regressions. If you want every release as soon as it ships, install `claude-code@latest` instead. The trade-off is that Homebrew installations do not auto-update by default. You need to run `brew upgrade claude-code` (or `brew upgrade claude-code@latest`) periodically to get new features and security fixes. For most developers who already use Homebrew for everything, the convenience of staying within a familiar package manager outweighs the manual update step.

To check which version you have installed:

```bash
claude --version
```

And to update later:

```bash
brew upgrade claude-code
```

The Homebrew installation places Claude Code in `/opt/homebrew/bin/` on Apple Silicon Macs or `/usr/local/bin/` on Intel Macs. If you later decide to switch to the native installer for auto-updates, uninstall the Homebrew version first with `brew uninstall --cask claude-code` to avoid having two copies of the binary in different locations, which can cause confusion about which version is running.

### Verify Your Installation

Regardless of which method you chose, verify that Claude Code is accessible by running:

```bash
which claude
claude --version
```

If `which claude` returns a path and `claude --version` shows a version number such as `2.1.301 (Claude Code)`, your installation is complete. If you get "command not found," check the troubleshooting section below. To see every copy on your PATH, run `which -a claude`; if it lists more than one path, keep only one install, as described in the migration section.

### If you searched for "Claude CLI": it is the same claude command

There is no separate "Claude CLI" download. The command-line tool is Claude Code, and the binary it installs is called `claude`, so "install the Claude CLI on a Mac" means one of the macOS methods above: the native installer (`curl -fsSL https://claude.ai/install.sh | bash`), the Homebrew cask (`brew install --cask claude-code`), or npm (`npm install -g @anthropic-ai/claude-code`, which needs Node.js 22 or later to install). The native installer and the npm route work the same way on Linux, and `claude --version` confirms the install on both.

Two Homebrew casks share the name, which is where "brew install claude desktop" searches come from. As checked on October 21, 2026, `brew install --cask claude` installs the Claude desktop app, while `brew install --cask claude-code` installs the terminal tool. If you ran the first one and still get "command not found: claude", install `claude-code` as well. The desktop app is covered in the FAQ below, and [Claude Code Desktop vs Terminal](https://blog.laozhang.ai/en/posts/claude-code-desktop-vs-terminal) compares the two ways of running it.

## Install Claude Code on Windows

![Windows installation decision tree showing Native PowerShell, WinGet, and WSL paths for Claude Code setup](https://blog.laozhang.ai/posts/en/how-to-install-claude-code/img/windows-decision.webp)

Windows installation involves one more decision than macOS or Linux: you need to choose between running Claude Code natively on Windows or inside WSL (Windows Subsystem for Linux). The right choice depends on your development workflow, and picking the wrong one leads to frustration. Let us walk through the decision and then cover each path in detail.

If you primarily write code that targets Windows — .NET applications, PowerShell scripts, Windows-native toolchains — use the native PowerShell installer. It runs directly on Windows, integrates with your existing PATH, and needs no prerequisites (Git for Windows is optional). If you primarily write code for Linux deployment — Node.js servers, Python backends, Docker containers — WSL gives you a genuine Linux environment where Claude Code behaves identically to macOS and Linux setups. If you are unsure, start with the native installer. You can always add WSL later.

### Native PowerShell Installer (Recommended for Most Users)

Git for Windows is optional. To see whether you already have it, open PowerShell and run `git --version`. If you see a version number, Claude Code will use Git Bash for its Bash tool. If not, Claude Code still installs and runs, using its PowerShell tool for shell commands; you can add Git from [git-scm.com](https://git-scm.com/downloads/win) later (select "Add to PATH" during setup, then restart PowerShell).

Run the installer in PowerShell (not CMD). A regular window is fine; you do not need to run it as Administrator:

```powershell
irm https://claude.ai/install.ps1 | iex
```

This downloads and installs the native binary at `%USERPROFILE%\.local\bin\claude.exe`, making the `claude` command available globally. Open a new PowerShell window after installation to ensure your PATH is updated. Like the macOS/Linux native installer, this version auto-updates in the background.

### WinGet Alternative

If you use WinGet (the Windows Package Manager that ships with Windows 11 and newer Windows 10 builds), Claude Code is available through the official repository:

```powershell
winget install Anthropic.ClaudeCode
```

This is functionally equivalent to the PowerShell installer but uses the Windows package management system. Note that WinGet installations do not auto-update by default — you need to run `winget upgrade Anthropic.ClaudeCode` periodically. WinGet is a great choice if your organization manages software through Windows Package Manager policies.

### Windows CMD Installer

For environments where PowerShell is restricted, there is also a CMD-compatible installer:

```cmd
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```

This is less common but useful in corporate environments with strict PowerShell execution policies.

**WSL Path (For Linux-First Developers)**

If you prefer a full Linux development environment on Windows, install WSL first and then use the standard Linux installation method inside it:

```powershell
# Step 1: Install WSL (in PowerShell as admin)
wsl --install

# Step 2: Reboot your computer when prompted

# Step 3: Open your WSL terminal (Ubuntu by default)
# Step 4: Install Claude Code using the Linux method
curl -fsSL https://claude.ai/install.sh | bash
```

A common mistake when using WSL is having Node.js installed on the Windows side but not inside the WSL environment. If you use the npm installation method through WSL, you need Node.js installed within WSL — the Windows Node.js installation is invisible to WSL. If npm inside WSL fails with `exec: node: not found`, WSL is picking up the Windows Node.js; install Node.js 22 or later inside WSL. The native installer avoids this problem entirely because it has no Node.js dependency.

For optimal WSL performance, make sure your project files live inside the WSL filesystem (e.g., `~/projects/`) rather than on the Windows filesystem (e.g., `/mnt/c/Users/...`). File operations across the WSL/Windows boundary are significantly slower and can cause timeouts in Claude Code.

## Migrate from npm to the Native Installer

If you previously installed Claude Code using `npm install -g @anthropic-ai/claude-code`, moving to the native installer is optional. Is the npm method deprecated? Not as of October 2026: the official setup docs still document the npm install under advanced installation options and do not call it deprecated, while the native installer remains the recommended method. The "deprecated" label comes from version 2.1.15 (January 21, 2026), which added a deprecation notice for npm installations; the 2.1.301 build for macOS no longer contains that notice.

Since version 2.1.113 (April 17, 2026), the npm package installs the same native binary as the standalone installer, so an up-to-date npm copy is not slower or less capable. Migrating still makes sense if you want one install that never touches Node.js, no npm global folder permissions to manage, and the method the docs recommend. The process takes about two minutes and preserves your existing configuration:

```bash
# Step 1: List every claude on your PATH
which -a claude
npm -g ls @anthropic-ai/claude-code  # shows a global npm install, if any

# Step 2: Uninstall the npm version
npm uninstall -g @anthropic-ai/claude-code
rm -rf ~/.claude/local  # only if an old local npm install lives here

# Step 3: Verify it's gone
which -a claude  # Should print nothing

# Step 4: Install the native version
curl -fsSL https://claude.ai/install.sh | bash  # macOS/Linux
# OR
irm https://claude.ai/install.ps1 | iex  # Windows PowerShell

# Step 5: Open a new terminal and verify
which -a claude  # Should list only ~/.local/bin/claude
claude --version
```

The goal is one copy of Claude Code. If `which -a claude` still lists a second path, such as a Homebrew or older npm copy, remove it too; on Windows, use `where.exe claude` to list copies. If an old npm copy fails with `Error: Cannot find module './yoga.wasm'`, see [the yoga.wasm fix](https://blog.laozhang.ai/en/posts/claude-code-cannot-find-module-yoga-wasm) for finding and removing that leftover install.

Your authentication tokens and configuration files (stored in `~/.claude/`) are preserved across this migration. You do not need to re-authenticate or reconfigure anything. The native binary simply takes over from where the npm version left off.

If you were using nvm or asdf to manage Node.js versions specifically for Claude Code, you can now simplify your setup by removing Claude Code from your Node.js dependency chain entirely. That also ends the "Node version mismatch" errors that affected the older JavaScript-based npm builds.

Startup speed is no longer a reason to migrate. It was one for npm builds up to 2.1.112, which ran a JavaScript file on Node.js at every launch. Since 2.1.113, the installed `claude` binary does not invoke Node at all, whichever of the two methods you used.

If you are managing Claude Code across a team, the native installer is still the simpler standard. With npm builds up to 2.1.112, every team member needed a compatible Node.js version at runtime, and version mismatches between developers caused "it works on my machine" problems. Today the npm route needs Node.js only to install, while the native installer removes Node.js from the setup entirely.

If you decide to stay on npm, keep three things in mind. The npm package requires Node.js 22 or later; on an older version, npm prints an `EBADENGINE` warning during install, but the install completes and `claude` still runs. Upgrade with `npm install -g @anthropic-ai/claude-code@latest` rather than `npm update -g`, which respects the version range from your original install and may not move you to the newest release. And never use `sudo npm install -g`.

## Authentication and First Launch

With Claude Code installed, the next step is authentication. Navigate to any project directory and run:

```bash
cd /path/to/your/project
claude
```

On first launch, Claude Code opens your default web browser to the Anthropic OAuth page. Log in with your Claude Pro, Max, or Teams account, authorize the CLI, and the browser redirects back to confirm success. A session token is stored locally in `~/.claude/` so you only need to do this once.

### Authentication Methods

Claude Code supports three authentication pathways, each suited to different use cases.

**Browser OAuth** is the default and works for most developers. When you run `claude` for the first time, it opens your browser automatically. If you are using Claude Pro or Max, this is the simplest path. Your subscription handles all billing, and you get the usage limits associated with your plan tier.

**API Key authentication** is designed for headless environments — CI/CD pipelines, Docker containers, remote servers without a browser. Set the `ANTHROPIC_API_KEY` environment variable before launching Claude Code:

```bash
export ANTHROPIC_API_KEY=sk-ant-...
claude
```

With an API key, billing goes through your Anthropic Console account on a pay-per-token basis.

**Third-party cloud providers** — Amazon Bedrock, Google Vertex AI, and Microsoft Foundry — are supported through environment variables:

```bash
# Amazon Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1

# Google Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project-id
```

These options are primarily used by enterprises that already have cloud provider agreements and prefer routing AI traffic through their existing infrastructure.

### Initialize Your Project with CLAUDE.md

After authenticating, the single most impactful thing you can do is create a `CLAUDE.md` file in your project root. This markdown file gives Claude persistent context about your codebase — build commands, code conventions, architecture decisions, testing instructions — anything Claude cannot infer from the code alone. Without it, Claude starts every session without understanding your project's unique patterns.

Generate a starter `CLAUDE.md` automatically:

```bash
# Inside a Claude Code session, run:
/init
```

This command analyzes your codebase and creates a `CLAUDE.md` with detected build systems, test frameworks, and code patterns. A good `CLAUDE.md` is concise — aim for 50 to 100 lines. For every line, ask yourself: "Would removing this cause Claude to make a mistake?" If not, cut it. For monorepos, add additional `CLAUDE.md` files in subdirectories. Claude loads them hierarchically — root-level rules apply everywhere, and child-level rules apply only when working in that directory.

The `/init` command also walks you through setting up essential Claude Code features like permission controls and preferred text formatting. It takes about a minute and makes a measurable difference in how accurately Claude works with your code.

Here is an example of what a well-structured `CLAUDE.md` looks like for a typical Next.js project:

```markdown
# CLAUDE.md

## Commands
- `npm run dev` - Start dev server on port 3000
- `npm run build` - Production build
- `npm test` - Run Jest tests
- `npm run lint` - ESLint check

## Architecture
- Next.js 15 with App Router
- PostgreSQL with Drizzle ORM
- Authentication via Clerk
- All API routes in src/app/api/

## Conventions
- Server components by default; use "use client" only when needed
- TypeScript strict mode; no any types
- Commit messages: imperative mood, < 72 chars
```

The key insight is that `CLAUDE.md` should tell Claude what it cannot figure out by reading your code directly. Your build commands, naming conventions, and architectural decisions are the most valuable things to include because these are the decisions Claude is most likely to get wrong without explicit guidance.

## Troubleshooting Common Installation Issues

About 60 percent of new users encounter at least one issue during installation or first launch, but the good news is that most problems resolve in under five minutes. The built-in diagnostic tool catches the majority of configuration problems automatically:

```bash
claude doctor
```

Run this command whenever something feels off. It checks your installation integrity, authentication state, configuration validity, and network connectivity, then reports what it finds. Below are the most common issues and their solutions.

### "command not found: claude"

This is the most frequent post-installation error and simply means your shell has not picked up the new PATH entry. The fix depends on your platform:

On macOS and Linux, open a new terminal window. If that does not work, manually reload your shell configuration:

```bash
source ~/.zshrc   # macOS (Zsh is default since Catalina)
source ~/.bashrc  # Linux (most distributions)
```

If the command is still not found, check that the installer actually added the PATH entry:

```bash
grep -r "claude" ~/.zshrc ~/.bashrc ~/.profile 2>/dev/null
```

On Windows, close PowerShell completely and reopen it. If the command is still not found, check that `%USERPROFILE%\.local\bin`, where the installer puts `claude.exe`, is on your PATH, and restart your machine as a last resort.

### EACCES Permission Errors (npm Method Only)

If you chose the npm installation method and encounter EACCES permission errors, never use `sudo npm install -g`. Running sudo with npm creates files owned by root in your npm directory, which causes cascading permission problems for every future npm global install.

The official first fix for npm permission errors is to switch to the native installer, which installs into your home folder without sudo: run `curl -fsSL https://claude.ai/install.sh | bash`, or `claude install` from your existing npm copy. If you want to stay on npm, give npm a global folder your user owns. This is the same fix `claude doctor` suggests when the npm global folder isn't writable:

```bash
mkdir -p ~/.npm-global
npm config set prefix ~/.npm-global
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc  # use ~/.zshrc on macOS
source ~/.bashrc
npm install -g @anthropic-ai/claude-code@latest
```

A writable global folder also lets an npm install update itself again; when it isn't writable, Claude Code shows a one-time notice at startup.

### Authentication Failures

If the browser redirect does not work during OAuth:

1. Confirm you are logged into [claude.ai](https://claude.ai) in the browser that opens
2. Check that your account is on a paid plan — Pro, Max, Teams, or Enterprise
3. Try logging out and back in: `claude auth logout` followed by `claude auth login` (inside a session, `/logout` also works)
4. For corporate networks with proxy configurations, you may need to set `HTTPS_PROXY` environment variable

For CI environments where no browser is available, switch to API key authentication as described in the authentication section above.

**Windows-Specific Issues**

If Claude Code stops with `Claude Code on Windows requires either Git for Windows (for bash) or PowerShell`, it found neither shell. Git for Windows is optional, so a missing Git alone does not cause this error. Make PowerShell reachable by adding `C:\Windows\System32\WindowsPowerShell\v1.0\` to your PATH or installing PowerShell 7 (`pwsh`). Alternatively, install Git for Windows with "Add to PATH" selected, restart your terminal, and run `claude` again.

If you see execution policy errors in PowerShell, you may need to temporarily allow script execution:

```powershell
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned
```

For WSL users experiencing slow file operations, move your project files from the Windows filesystem (`/mnt/c/...`) into the WSL filesystem (`~/projects/`). Cross-filesystem access through WSL adds significant latency that compounds with Claude Code's frequent file reads.

**Network and Proxy Issues**

Corporate networks with proxy servers can block the installation script or the OAuth authentication flow. If `curl` times out during installation, configure your proxy settings before running the installer:

```bash
export HTTPS_PROXY=http://proxy.yourcompany.com:8080
export HTTP_PROXY=http://proxy.yourcompany.com:8080
curl -fsSL https://claude.ai/install.sh | bash
```

If authentication fails behind a proxy, the same environment variables usually resolve the issue. Some corporate firewalls specifically block WebSocket connections, which Claude Code uses for real-time communication. In this case, contact your IT department to whitelist `claude.ai` and `api.anthropic.com` domains.

**Slow Performance After Installation**

If Claude Code starts but responds slowly, the most common cause is an overloaded context window. Running `/compact` inside a session compresses your conversation history and frees up context space. For projects with very large codebases, creating a `.claudeignore` file (similar to `.gitignore`) prevents Claude from scanning directories that are not relevant to your work, such as `node_modules`, `dist`, or large binary asset folders.

## Which Claude Code Plan Is Right for You?

![Claude Code plan comparison showing Pro, Max 5x, Max 20x, and API options with pricing and features](https://blog.laozhang.ai/posts/en/how-to-install-claude-code/img/plan-comparison.webp)

Choosing the right plan prevents both overspending and frustrating rate limits. The decision comes down to how often you use Claude Code and whether you need the most powerful model.

**Claude Pro at $20 per month** is the starting point for most individual developers. It gives you access to Claude Sonnet 4.6 in the terminal and the web interface, with usage measured over rolling five-hour windows. For developers who use Claude Code a few times a day for code reviews, bug fixes, and small features, Pro is sufficient. Based on community estimates, Pro users typically get 40 to 80 Sonnet hours per week, which covers moderate daily usage comfortably.

**Claude Max at $100 per month (5x tier)** makes sense when you hit rate limits on Pro regularly — typically developers who keep Claude Code running as an active pair programmer throughout their workday. The 5x multiplier translates to roughly 140 to 280 Sonnet hours per week, and you also get access to Claude Opus 4.6, the most powerful model in the lineup. If you find yourself waiting for rate limit resets more than once or twice a week on Pro, upgrading to Max 5x usually pays for itself in recovered productivity.

**Claude Max at $200 per month (20x tier)** is for power users and leads running Claude Code across multiple projects simultaneously. With approximately 240 to 480 Sonnet hours per week, you are unlikely to ever hit a rate limit. This tier is also popular among developers who use Claude Code extensively for large-scale refactoring, automated testing, and continuous code review workflows.

**Anthropic Console (pay-as-you-go API)** is the best choice if your usage is sporadic or if you primarily run Claude Code in CI/CD pipelines. Instead of a monthly subscription, you load credits and pay per token consumed. Current pricing for Claude Sonnet 4.6 is $3.00 per million input tokens and $15.00 per million output tokens (Anthropic Console, March 2026). A single Claude Code command typically generates 8 to 12 API calls, so a heavy session might consume $0.50 to $2.00 in API costs, making it significantly cheaper than a subscription for occasional use.

For teams evaluating Claude Code, the Teams Standard plan at $25 per seat per month ($20 annual) provides Pro-level access with centralized administration. If your team decides to upgrade, the Teams Premium plan at $125 per seat per month ($100 annual) adds 5x usage limits comparable to Max. For more details on managing rate limits effectively, see [our detailed guide to Claude Code rate limits](https://blog.laozhang.ai/en/posts/claude-code-rate-limit-reached).

## Comparing Installation Methods at a Glance

With six different ways to install Claude Code, it helps to see them side by side. The table below summarizes the key differences so you can pick the right method for your environment:

| Method | Platform | Command | Auto-Updates | Dependencies | Best For |
|--------|---------|---------|-------------|-------------|---------|
| Native CLI | macOS, Linux, WSL | `curl -fsSL https://claude.ai/install.sh \| bash` | Yes | None | Most users |
| Native PowerShell | Windows | `irm https://claude.ai/install.ps1 \| iex` | Yes | None (Git for Windows optional) | Windows users |
| Homebrew | macOS, Linux | `brew install --cask claude-code` | No (manual by default) | Homebrew | Homebrew users |
| WinGet | Windows | `winget install Anthropic.ClaudeCode` | No (manual by default) | WinGet | Windows pkg mgmt |
| npm | All platforms | `npm install -g @anthropic-ai/claude-code` | Yes, if the npm global folder is writable | Node.js 22+ (install only) | Existing npm setups |
| WSL | Windows | Linux installer inside WSL | Yes (via Linux) | WSL2 | Linux-first devs |

The native installer is the recommended method for the vast majority of users. It has zero dependencies, auto-updates silently, and provides the most stable experience. Homebrew and WinGet are solid alternatives if you prefer managing tools through a package manager and do not mind running updates manually. The npm method is still documented and installs the same native binary, so it suits teams that already manage tools through npm. It needs Node.js 22 or later to install (older versions only print an `EBADENGINE` warning), and you upgrade it with `npm install -g @anthropic-ai/claude-code@latest`.

**Frequently Asked Questions**

**Does Claude Code require Node.js?** No. The native installer, Homebrew, and WinGet need no Node.js at all. The npm route needs Node.js 22 or later to install, but the `claude` binary it installs does not use Node.js at runtime. On an older Node.js version, npm prints an `EBADENGINE` warning and the install still completes.

**Can I use Claude Code on Apple Silicon?** Yes. The native installer detects your architecture automatically and downloads the ARM64 binary for Apple Silicon Macs.

**How do I completely uninstall Claude Code?** Remove it the same way you installed it; there is no `claude uninstall` command. For the native installer on macOS, Linux, or WSL, run `rm -f ~/.local/bin/claude` and `rm -rf ~/.local/share/claude` (on Windows, delete `%USERPROFILE%\.local\bin\claude.exe` and the `%USERPROFILE%\.local\share\claude` folder). For Homebrew, run `brew uninstall --cask claude-code`. For WinGet, run `winget uninstall Anthropic.ClaudeCode`. For npm, run `npm uninstall -g @anthropic-ai/claude-code`. Your settings stay in `~/.claude/` and `~/.claude.json`. Deleting them is a separate, optional step (`rm -rf ~/.claude` and `rm ~/.claude.json`) that also erases your settings, MCP server configurations, and session history. If the VS Code extension, JetBrains plugin, or desktop app is still installed, it recreates `~/.claude/` the next time it runs.

**Can I use Claude Code without a subscription?** Not through the standard installation. You need either a paid Claude subscription (Pro, Max, Teams, Enterprise) or an Anthropic Console account with API credits. There is no free tier for Claude Code itself, though the Console option lets you pay only for what you use.

**Does Claude Code work in VS Code?** Yes. Claude Code is available as a VS Code extension and a JetBrains plugin, in addition to the terminal CLI covered in this guide. The installation methods here set up the core CLI, which the IDE extensions build upon. Install the extension from the VS Code marketplace by searching for "Claude Code" and clicking install — it connects to the same CLI binary you just installed.

**Is there a desktop app for Claude Code?** Yes. Anthropic launched the Claude Code desktop app which provides a graphical interface alongside the terminal functionality. You can download it from claude.ai after logging in. The desktop app and the terminal CLI share the same authentication and configuration, so installing one gives you access to both.

## Final Thoughts and Next Steps

Installing Claude Code in 2026 is remarkably simple compared to just a year ago. The native installer eliminated the Node.js dependency that caused the majority of installation headaches, and the addition of WinGet and CMD installers gave Windows users proper first-class support. Whether you chose the one-line native installer, Homebrew, or WinGet, the hard part is over.

Now that Claude Code is running on your machine, here are the most valuable next steps. First, run `/init` inside Claude Code to generate your project's `CLAUDE.md` — this single step dramatically improves the quality of Claude's responses by giving it persistent context about your codebase. Second, explore the built-in slash commands by typing `/help` — you will find shortcuts for common workflows like code review, commit generation, and test writing. Third, consider connecting MCP (Model Context Protocol) servers to give Claude Code direct access to your tools and data sources, turning it from a coding assistant into a proper development agent.

If you are evaluating Claude Code alongside other AI coding tools, our comparison of [how Claude Code stacks up against OpenClaw](https://blog.laozhang.ai/en/posts/openclaw-vs-claude-code) provides a detailed breakdown of strengths, weaknesses, and ideal use cases for each tool. For developers already using Claude Code and running into usage limits, our guide on [managing Claude Code rate limits](https://blog.laozhang.ai/en/posts/claude-code-rate-limit-reached) covers practical strategies for maximizing your available quota.

For a broader perspective on which AI coding tools fit different workflows, our comparison of [connecting AI tools through API providers](https://blog.laozhang.ai/en/posts/openclaw-api-guide) covers how to set up flexible multi-model access that works alongside Claude Code.

The future of AI-assisted coding is here, and it runs in your terminal. Happy coding.

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-10-21.

- [git-scm.com](https://git-scm.com/downloads/win) (git-scm.com)
- [claude.ai](https://claude.ai/) (claude.ai)